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

In audio/ replace mock macros with unified MOCK_METHOD macro

Browse Source 
Bug: webrtc:11564
Change-Id: Ibdefed35fc73c8bf74db47df7469af7968f8e59d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/175138
Reviewed-by: Per Åhgren <peah@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31274}
This commit is contained in:
Danil Chapovalov 2020-05-15 11:40:44 +02:00 committed by Commit Bot
parent 6866dc7806
commit f9c6b68057
3 changed files with 154 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
audio/audio_send_stream_unittest.cc
View File

@ -89,7 +89,10 @@ const DataRate kMaxOverheadRate = kOverheadPerPacket / kMinFrameLength;
class MockLimitObserver : public BitrateAllocator::LimitObserver {
public:
MOCK_METHOD1(OnAllocationLimitsChanged, void(BitrateAllocationLimits));
MOCK_METHOD(void,
OnAllocationLimitsChanged,
(BitrateAllocationLimits),
(override));
};
std::unique_ptr<MockAudioEncoder> SetupAudioEncoderMock(
@ -247,12 +250,12 @@ struct ConfigHelper {
void SetupMockForSetupSendCodec(bool expect_set_encoder_call) {
if (expect_set_encoder_call) {
EXPECT_CALL(*channel_send_, SetEncoderForMock(_, _))
.WillOnce(Invoke(
[this](int payload_type, std::unique_ptr<AudioEncoder>* encoder) {
this->audio_encoder_ = std::move(*encoder);
EXPECT_CALL(*channel_send_, SetEncoder)
.WillOnce(
[this](int payload_type, std::unique_ptr<AudioEncoder> encoder) {
this->audio_encoder_ = std::move(encoder);
return true;
}));
});
}
}
@ -473,7 +476,7 @@ TEST(AudioSendStreamTest, GetStatsAudioLevel) {
ConfigHelper helper(false, true, use_null_audio_processing);
auto send_stream = helper.CreateAudioSendStream();
helper.SetupMockForGetStats(use_null_audio_processing);
EXPECT_CALL(*helper.channel_send(), ProcessAndEncodeAudioForMock(_))
EXPECT_CALL(*helper.channel_send(), ProcessAndEncodeAudio)
.Times(AnyNumber());
constexpr int kSampleRateHz = 48000;
@ -558,15 +561,13 @@ TEST(AudioSendStreamTest, SendCodecCanApplyVad) {
helper.config().send_codec_spec =
AudioSendStream::Config::SendCodecSpec(9, kG722Format);
helper.config().send_codec_spec->cng_payload_type = 105;
using ::testing::Invoke;
std::unique_ptr<AudioEncoder> stolen_encoder;
EXPECT_CALL(*helper.channel_send(), SetEncoderForMock(_, _))
.WillOnce(
Invoke([&stolen_encoder](int payload_type,
std::unique_ptr<AudioEncoder>* encoder) {
stolen_encoder = std::move(*encoder);
return true;
}));
EXPECT_CALL(*helper.channel_send(), SetEncoder)
.WillOnce([&stolen_encoder](int payload_type,
std::unique_ptr<AudioEncoder> encoder) {
stolen_encoder = std::move(encoder);
return true;
});
EXPECT_CALL(*helper.channel_send(), RegisterCngPayloadType(105, 8000));
auto send_stream = helper.CreateAudioSendStream();
@ -748,8 +749,7 @@ TEST(AudioSendStreamTest, DontRecreateEncoder) {
// test to be correct, it's instead set-up manually here. Otherwise a simple
// change to ConfigHelper (say to WillRepeatedly) would silently make this
// test useless.
EXPECT_CALL(*helper.channel_send(), SetEncoderForMock(_, _))
.WillOnce(Return());
EXPECT_CALL(*helper.channel_send(), SetEncoder).WillOnce(Return());
EXPECT_CALL(*helper.channel_send(), RegisterCngPayloadType(105, 8000));

6
audio/audio_state_unittest.cc
View File

@ -60,8 +60,10 @@ class FakeAudioSource : public AudioMixer::Source {
int PreferredSampleRate() const /*override*/ { return kSampleRate; }
MOCK_METHOD2(GetAudioFrameWithInfo,
AudioFrameInfo(int sample_rate_hz, AudioFrame* audio_frame));
MOCK_METHOD(AudioFrameInfo,
GetAudioFrameWithInfo,
(int sample_rate_hz, AudioFrame*),
(override));
};
std::vector<int16_t> Create10msTestData(int sample_rate_hz,

224
audio/mock_voe_channel_proxy.h
View File

@ -28,102 +28,144 @@ namespace test {
class MockChannelReceive : public voe::ChannelReceiveInterface {
public:
MOCK_METHOD2(SetNACKStatus, void(bool enable, int max_packets));
MOCK_METHOD1(RegisterReceiverCongestionControlObjects,
void(PacketRouter* packet_router));
MOCK_METHOD0(ResetReceiverCongestionControlObjects, void());
MOCK_CONST_METHOD0(GetRTCPStatistics, CallReceiveStatistics());
MOCK_CONST_METHOD0(GetNetworkStatistics, NetworkStatistics());
MOCK_CONST_METHOD0(GetDecodingCallStatistics, AudioDecodingCallStats());
MOCK_CONST_METHOD0(GetSpeechOutputLevelFullRange, int());
MOCK_CONST_METHOD0(GetTotalOutputEnergy, double());
MOCK_CONST_METHOD0(GetTotalOutputDuration, double());
MOCK_CONST_METHOD0(GetDelayEstimate, uint32_t());
MOCK_METHOD1(SetSink, void(AudioSinkInterface* sink));
MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived& packet));
MOCK_METHOD2(ReceivedRTCPPacket, void(const uint8_t* packet, size_t length));
MOCK_METHOD1(SetChannelOutputVolumeScaling, void(float scaling));
MOCK_METHOD2(GetAudioFrameWithInfo,
AudioMixer::Source::AudioFrameInfo(int sample_rate_hz,
AudioFrame* audio_frame));
MOCK_CONST_METHOD0(PreferredSampleRate, int());
MOCK_METHOD1(SetAssociatedSendChannel,
void(const voe::ChannelSendInterface* send_channel));
MOCK_CONST_METHOD2(GetPlayoutRtpTimestamp,
bool(uint32_t* rtp_timestamp, int64_t* time_ms));
MOCK_METHOD2(SetEstimatedPlayoutNtpTimestampMs,
void(int64_t ntp_timestamp_ms, int64_t time_ms));
MOCK_CONST_METHOD1(GetCurrentEstimatedPlayoutNtpTimestampMs,
absl::optional<int64_t>(int64_t now_ms));
MOCK_CONST_METHOD0(GetSyncInfo, absl::optional<Syncable::Info>());
MOCK_METHOD1(SetMinimumPlayoutDelay, void(int delay_ms));
MOCK_METHOD1(SetBaseMinimumPlayoutDelayMs, bool(int delay_ms));
MOCK_CONST_METHOD0(GetBaseMinimumPlayoutDelayMs, int());
MOCK_CONST_METHOD0(GetReceiveCodec,
absl::optional<std::pair<int, SdpAudioFormat>>());
MOCK_METHOD1(SetReceiveCodecs,
void(const std::map<int, SdpAudioFormat>& codecs));
MOCK_CONST_METHOD0(GetSources, std::vector<RtpSource>());
MOCK_METHOD0(StartPlayout, void());
MOCK_METHOD0(StopPlayout, void());
MOCK_METHOD1(SetDepacketizerToDecoderFrameTransformer,
void(rtc::scoped_refptr<webrtc::FrameTransformerInterface>
frame_transformer));
MOCK_METHOD(void, SetNACKStatus, (bool enable, int max_packets), (override));
MOCK_METHOD(void,
RegisterReceiverCongestionControlObjects,
(PacketRouter*),
(override));
MOCK_METHOD(void, ResetReceiverCongestionControlObjects, (), (override));
MOCK_METHOD(CallReceiveStatistics, GetRTCPStatistics, (), (const, override));
MOCK_METHOD(NetworkStatistics, GetNetworkStatistics, (), (const, override));
MOCK_METHOD(AudioDecodingCallStats,
GetDecodingCallStatistics,
(),
(const, override));
MOCK_METHOD(int, GetSpeechOutputLevelFullRange, (), (const, override));
MOCK_METHOD(double, GetTotalOutputEnergy, (), (const, override));
MOCK_METHOD(double, GetTotalOutputDuration, (), (const, override));
MOCK_METHOD(uint32_t, GetDelayEstimate, (), (const, override));
MOCK_METHOD(void, SetSink, (AudioSinkInterface*), (override));
MOCK_METHOD(void, OnRtpPacket, (const RtpPacketReceived& packet), (override));
MOCK_METHOD(void,
ReceivedRTCPPacket,
(const uint8_t*, size_t length),
(override));
MOCK_METHOD(void, SetChannelOutputVolumeScaling, (float scaling), (override));
MOCK_METHOD(AudioMixer::Source::AudioFrameInfo,
GetAudioFrameWithInfo,
(int sample_rate_hz, AudioFrame*),
(override));
MOCK_METHOD(int, PreferredSampleRate, (), (const, override));
MOCK_METHOD(void,
SetAssociatedSendChannel,
(const voe::ChannelSendInterface*),
(override));
MOCK_METHOD(bool,
GetPlayoutRtpTimestamp,
(uint32_t*, int64_t*),
(const, override));
MOCK_METHOD(void,
SetEstimatedPlayoutNtpTimestampMs,
(int64_t ntp_timestamp_ms, int64_t time_ms),
(override));
MOCK_METHOD(absl::optional<int64_t>,
GetCurrentEstimatedPlayoutNtpTimestampMs,
(int64_t now_ms),
(const, override));
MOCK_METHOD(absl::optional<Syncable::Info>,
GetSyncInfo,
(),
(const, override));
MOCK_METHOD(void, SetMinimumPlayoutDelay, (int delay_ms), (override));
MOCK_METHOD(bool, SetBaseMinimumPlayoutDelayMs, (int delay_ms), (override));
MOCK_METHOD(int, GetBaseMinimumPlayoutDelayMs, (), (const, override));
MOCK_METHOD((absl::optional<std::pair<int, SdpAudioFormat>>),
GetReceiveCodec,
(),
(const, override));
MOCK_METHOD(void,
SetReceiveCodecs,
((const std::map<int, SdpAudioFormat>& codecs)),
(override));
MOCK_METHOD(void, StartPlayout, (), (override));
MOCK_METHOD(void, StopPlayout, (), (override));
MOCK_METHOD(
void,
SetDepacketizerToDecoderFrameTransformer,
(rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer),
(override));
};
class MockChannelSend : public voe::ChannelSendInterface {
public:
// GMock doesn't like move-only types, like std::unique_ptr.
virtual void SetEncoder(int payload_type,
std::unique_ptr<AudioEncoder> encoder) {
return SetEncoderForMock(payload_type, &encoder);
}
MOCK_METHOD2(SetEncoderForMock,
void(int payload_type, std::unique_ptr<AudioEncoder>* encoder));
MOCK_METHOD1(
MOCK_METHOD(void,
SetEncoder,
(int payload_type, std::unique_ptr<AudioEncoder> encoder),
(override));
MOCK_METHOD(
void,
ModifyEncoder,
void(rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier));
MOCK_METHOD1(CallEncoder,
void(rtc::FunctionView<void(AudioEncoder*)> modifier));
MOCK_METHOD1(SetRTCP_CNAME, void(absl::string_view c_name));
MOCK_METHOD2(SetSendAudioLevelIndicationStatus, void(bool enable, int id));
MOCK_METHOD2(RegisterSenderCongestionControlObjects,
void(RtpTransportControllerSendInterface* transport,
RtcpBandwidthObserver* bandwidth_observer));
MOCK_METHOD0(ResetSenderCongestionControlObjects, void());
MOCK_CONST_METHOD0(GetRTCPStatistics, CallSendStatistics());
MOCK_CONST_METHOD0(GetRemoteRTCPReportBlocks, std::vector<ReportBlock>());
MOCK_CONST_METHOD0(GetANAStatistics, ANAStats());
MOCK_METHOD2(RegisterCngPayloadType,
void(int payload_type, int payload_frequency));
MOCK_METHOD2(SetSendTelephoneEventPayloadType,
void(int payload_type, int payload_frequency));
MOCK_METHOD2(SendTelephoneEventOutband, bool(int event, int duration_ms));
MOCK_METHOD1(OnBitrateAllocation, void(BitrateAllocationUpdate update));
MOCK_METHOD1(SetInputMute, void(bool muted));
MOCK_METHOD2(ReceivedRTCPPacket, void(const uint8_t* packet, size_t length));
// GMock doesn't like move-only types, like std::unique_ptr.
virtual void ProcessAndEncodeAudio(std::unique_ptr<AudioFrame> audio_frame) {
ProcessAndEncodeAudioForMock(&audio_frame);
}
MOCK_METHOD1(ProcessAndEncodeAudioForMock,
void(std::unique_ptr<AudioFrame>* audio_frame));
MOCK_METHOD1(SetTransportOverhead,
void(size_t transport_overhead_per_packet));
MOCK_CONST_METHOD0(GetRtpRtcp, RtpRtcp*());
MOCK_CONST_METHOD0(GetBitrate, int());
MOCK_METHOD1(OnTwccBasedUplinkPacketLossRate, void(float packet_loss_rate));
MOCK_METHOD1(OnRecoverableUplinkPacketLossRate,
void(float recoverable_packet_loss_rate));
MOCK_CONST_METHOD0(GetRTT, int64_t());
MOCK_METHOD0(StartSend, void());
MOCK_METHOD0(StopSend, void());
MOCK_METHOD1(
SetFrameEncryptor,
void(rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor));
MOCK_METHOD1(SetEncoderToPacketizerFrameTransformer,
void(rtc::scoped_refptr<webrtc::FrameTransformerInterface>
frame_transformer));
(rtc::FunctionView<void(std::unique_ptr<AudioEncoder>*)> modifier),
(override));
MOCK_METHOD(void,
CallEncoder,
(rtc::FunctionView<void(AudioEncoder*)> modifier),
(override));
MOCK_METHOD(void, SetRTCP_CNAME, (absl::string_view c_name), (override));
MOCK_METHOD(void,
SetSendAudioLevelIndicationStatus,
(bool enable, int id),
(override));
MOCK_METHOD(void,
RegisterSenderCongestionControlObjects,
(RtpTransportControllerSendInterface*, RtcpBandwidthObserver*),
(override));
MOCK_METHOD(void, ResetSenderCongestionControlObjects, (), (override));
MOCK_METHOD(CallSendStatistics, GetRTCPStatistics, (), (const, override));
MOCK_METHOD(std::vector<ReportBlock>,
GetRemoteRTCPReportBlocks,
(),
(const, override));
MOCK_METHOD(ANAStats, GetANAStatistics, (), (const, override));
MOCK_METHOD(void,
RegisterCngPayloadType,
(int payload_type, int payload_frequency),
(override));
MOCK_METHOD(void,
SetSendTelephoneEventPayloadType,
(int payload_type, int payload_frequency),
(override));
MOCK_METHOD(bool,
SendTelephoneEventOutband,
(int event, int duration_ms),
(override));
MOCK_METHOD(void,
OnBitrateAllocation,
(BitrateAllocationUpdate update),
(override));
MOCK_METHOD(void, SetInputMute, (bool muted), (override));
MOCK_METHOD(void,
ReceivedRTCPPacket,
(const uint8_t*, size_t length),
(override));
MOCK_METHOD(void,
ProcessAndEncodeAudio,
(std::unique_ptr<AudioFrame>),
(override));
MOCK_METHOD(RtpRtcp*, GetRtpRtcp, (), (const, override));
MOCK_METHOD(int, GetBitrate, (), (const, override));
MOCK_METHOD(int64_t, GetRTT, (), (const, override));
MOCK_METHOD(void, StartSend, (), (override));
MOCK_METHOD(void, StopSend, (), (override));
MOCK_METHOD(void,
SetFrameEncryptor,
(rtc::scoped_refptr<FrameEncryptorInterface> frame_encryptor),
(override));
MOCK_METHOD(
void,
SetEncoderToPacketizerFrameTransformer,
(rtc::scoped_refptr<webrtc::FrameTransformerInterface> frame_transformer),
(override));
};
} // namespace test
} // namespace webrtc