zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

In common_audio/ and modules/audio_* replace mock macros with unified MOCK_METHOD macro

Browse Source 
Bug: webrtc:11564
Change-Id: Ib0ffce4de50a13b018926f6ea2865a2ec2fb2ec7
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/175621
Reviewed-by: Henrik Lundin <henrik.lundin@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31333}
This commit is contained in:
Danil Chapovalov
2020-05-18 15:10:15 +02:00
committed by Commit Bot
parent b46df3da44
commit 704fb55255
31 changed files with 511 additions and 396 deletions
Download Patch File Download Diff File Expand all files Collapse all files

35
modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h
View File

@ -18,27 +18,38 @@ namespace webrtc {
class MockAudioNetworkAdaptor : public AudioNetworkAdaptor {
public:
virtual ~MockAudioNetworkAdaptor() { Die(); }
MOCK_METHOD0(Die, void());
~MockAudioNetworkAdaptor() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD1(SetUplinkBandwidth, void(int uplink_bandwidth_bps));
MOCK_METHOD(void, SetUplinkBandwidth, (int uplink_bandwidth_bps), (override));
MOCK_METHOD1(SetUplinkPacketLossFraction,
void(float uplink_packet_loss_fraction));
MOCK_METHOD(void,
SetUplinkPacketLossFraction,
(float uplink_packet_loss_fraction),
(override));
MOCK_METHOD1(SetRtt, void(int rtt_ms));
MOCK_METHOD(void, SetRtt, (int rtt_ms), (override));
MOCK_METHOD1(SetTargetAudioBitrate, void(int target_audio_bitrate_bps));
MOCK_METHOD(void,
SetTargetAudioBitrate,
(int target_audio_bitrate_bps),
(override));
MOCK_METHOD1(SetOverhead, void(size_t overhead_bytes_per_packet));
MOCK_METHOD(void,
SetOverhead,
(size_t overhead_bytes_per_packet),
(override));
MOCK_METHOD0(GetEncoderRuntimeConfig, AudioEncoderRuntimeConfig());
MOCK_METHOD(AudioEncoderRuntimeConfig,
GetEncoderRuntimeConfig,
(),
(override));
MOCK_METHOD1(StartDebugDump, void(FILE* file_handle));
MOCK_METHOD(void, StartDebugDump, (FILE * file_handle), (override));
MOCK_METHOD0(StopDebugDump, void());
MOCK_METHOD(void, StopDebugDump, (), (override));
MOCK_CONST_METHOD0(GetStats, ANAStats());
MOCK_METHOD(ANAStats, GetStats, (), (const, override));
};
} // namespace webrtc

15
modules/audio_coding/audio_network_adaptor/mock/mock_controller.h
View File

@ -18,11 +18,16 @@ namespace webrtc {
class MockController : public Controller {
public:
virtual ~MockController() { Die(); }
MOCK_METHOD0(Die, void());
MOCK_METHOD1(UpdateNetworkMetrics,
void(const NetworkMetrics& network_metrics));
MOCK_METHOD1(MakeDecision, void(AudioEncoderRuntimeConfig* config));
~MockController() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD(void,
UpdateNetworkMetrics,
(const NetworkMetrics& network_metrics),
(override));
MOCK_METHOD(void,
MakeDecision,
(AudioEncoderRuntimeConfig * config),
(override));
};
} // namespace webrtc

13
modules/audio_coding/audio_network_adaptor/mock/mock_controller_manager.h
View File

@ -20,12 +20,13 @@ namespace webrtc {
class MockControllerManager : public ControllerManager {
public:
virtual ~MockControllerManager() { Die(); }
MOCK_METHOD0(Die, void());
MOCK_METHOD1(
GetSortedControllers,
std::vector<Controller*>(const Controller::NetworkMetrics& metrics));
MOCK_CONST_METHOD0(GetControllers, std::vector<Controller*>());
~MockControllerManager() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD(std::vector<Controller*>,
GetSortedControllers,
(const Controller::NetworkMetrics& metrics),
(override));
MOCK_METHOD(std::vector<Controller*>, GetControllers, (), (const, override));
};
} // namespace webrtc

28
modules/audio_coding/audio_network_adaptor/mock/mock_debug_dump_writer.h
View File

@ -18,20 +18,24 @@ namespace webrtc {
class MockDebugDumpWriter : public DebugDumpWriter {
public:
virtual ~MockDebugDumpWriter() { Die(); }
MOCK_METHOD0(Die, void());
~MockDebugDumpWriter() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD2(DumpEncoderRuntimeConfig,
void(const AudioEncoderRuntimeConfig& config,
int64_t timestamp));
MOCK_METHOD2(DumpNetworkMetrics,
void(const Controller::NetworkMetrics& metrics,
int64_t timestamp));
MOCK_METHOD(void,
DumpEncoderRuntimeConfig,
(const AudioEncoderRuntimeConfig& config, int64_t timestamp),
(override));
MOCK_METHOD(void,
DumpNetworkMetrics,
(const Controller::NetworkMetrics& metrics, int64_t timestamp),
(override));
#if WEBRTC_ENABLE_PROTOBUF
MOCK_METHOD2(DumpControllerManagerConfig,
void(const audio_network_adaptor::config::ControllerManager&
controller_manager_config,
int64_t timestamp));
MOCK_METHOD(void,
DumpControllerManagerConfig,
(const audio_network_adaptor::config::ControllerManager&
controller_manager_config,
int64_t timestamp),
(override));
#endif
};

38
modules/audio_coding/neteq/mock/mock_decoder_database.h
View File

@ -23,22 +23,28 @@ class MockDecoderDatabase : public DecoderDatabase {
explicit MockDecoderDatabase(
rtc::scoped_refptr<AudioDecoderFactory> factory = nullptr)
: DecoderDatabase(factory, absl::nullopt) {}
virtual ~MockDecoderDatabase() { Die(); }
MOCK_METHOD0(Die, void());
MOCK_CONST_METHOD0(Empty, bool());
MOCK_CONST_METHOD0(Size, int());
MOCK_METHOD0(Reset, void());
MOCK_METHOD2(RegisterPayload,
int(int rtp_payload_type, const SdpAudioFormat& audio_format));
MOCK_METHOD1(Remove, int(uint8_t rtp_payload_type));
MOCK_METHOD0(RemoveAll, void());
MOCK_CONST_METHOD1(GetDecoderInfo,
const DecoderInfo*(uint8_t rtp_payload_type));
MOCK_METHOD2(SetActiveDecoder,
int(uint8_t rtp_payload_type, bool* new_decoder));
MOCK_CONST_METHOD0(GetActiveDecoder, AudioDecoder*());
MOCK_METHOD1(SetActiveCngDecoder, int(uint8_t rtp_payload_type));
MOCK_CONST_METHOD0(GetActiveCngDecoder, ComfortNoiseDecoder*());
~MockDecoderDatabase() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD(bool, Empty, (), (const, override));
MOCK_METHOD(int, Size, (), (const, override));
MOCK_METHOD(void, Reset, (), (override));
MOCK_METHOD(int,
RegisterPayload,
(int rtp_payload_type, const SdpAudioFormat& audio_format),
(override));
MOCK_METHOD(int, Remove, (uint8_t rtp_payload_type), (override));
MOCK_METHOD(void, RemoveAll, (), (override));
MOCK_METHOD(const DecoderInfo*,
GetDecoderInfo,
(uint8_t rtp_payload_type),
(const, override));
MOCK_METHOD(int,
SetActiveDecoder,
(uint8_t rtp_payload_type, bool* new_decoder),
(override));
MOCK_METHOD(AudioDecoder*, GetActiveDecoder, (), (const, override));
MOCK_METHOD(int, SetActiveCngDecoder, (uint8_t rtp_payload_type), (override));
MOCK_METHOD(ComfortNoiseDecoder*, GetActiveCngDecoder, (), (const, override));
};
} // namespace webrtc

17
modules/audio_coding/neteq/mock/mock_dtmf_buffer.h
View File

@ -19,13 +19,16 @@ namespace webrtc {
class MockDtmfBuffer : public DtmfBuffer {
public:
MockDtmfBuffer(int fs) : DtmfBuffer(fs) {}
virtual ~MockDtmfBuffer() { Die(); }
MOCK_METHOD0(Die, void());
MOCK_METHOD0(Flush, void());
MOCK_METHOD1(InsertEvent, int(const DtmfEvent& event));
MOCK_METHOD2(GetEvent, bool(uint32_t current_timestamp, DtmfEvent* event));
MOCK_CONST_METHOD0(Length, size_t());
MOCK_CONST_METHOD0(Empty, bool());
~MockDtmfBuffer() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD(void, Flush, (), (override));
MOCK_METHOD(int, InsertEvent, (const DtmfEvent& event), (override));
MOCK_METHOD(bool,
GetEvent,
(uint32_t current_timestamp, DtmfEvent* event),
(override));
MOCK_METHOD(size_t, Length, (), (const, override));
MOCK_METHOD(bool, Empty, (), (const, override));
};
} // namespace webrtc

15
modules/audio_coding/neteq/mock/mock_dtmf_tone_generator.h
View File

@ -18,12 +18,15 @@ namespace webrtc {
class MockDtmfToneGenerator : public DtmfToneGenerator {
public:
virtual ~MockDtmfToneGenerator() { Die(); }
MOCK_METHOD0(Die, void());
MOCK_METHOD3(Init, int(int fs, int event, int attenuation));
MOCK_METHOD0(Reset, void());
MOCK_METHOD2(Generate, int(size_t num_samples, AudioMultiVector* output));
MOCK_CONST_METHOD0(initialized, bool());
~MockDtmfToneGenerator() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD(int, Init, (int fs, int event, int attenuation), (override));
MOCK_METHOD(void, Reset, (), (override));
MOCK_METHOD(int,
Generate,
(size_t num_samples, AudioMultiVector* output),
(override));
MOCK_METHOD(bool, initialized, (), (const, override));
};
} // namespace webrtc

30
modules/audio_coding/neteq/mock/mock_expand.h
View File

@ -30,13 +30,13 @@ class MockExpand : public Expand {
statistics,
fs,
num_channels) {}
virtual ~MockExpand() { Die(); }
MOCK_METHOD0(Die, void());
MOCK_METHOD0(Reset, void());
MOCK_METHOD1(Process, int(AudioMultiVector* output));
MOCK_METHOD0(SetParametersForNormalAfterExpand, void());
MOCK_METHOD0(SetParametersForMergeAfterExpand, void());
MOCK_CONST_METHOD0(overlap_length, size_t());
~MockExpand() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD(void, Reset, (), (override));
MOCK_METHOD(int, Process, (AudioMultiVector * output), (override));
MOCK_METHOD(void, SetParametersForNormalAfterExpand, (), (override));
MOCK_METHOD(void, SetParametersForMergeAfterExpand, (), (override));
MOCK_METHOD(size_t, overlap_length, (), (const, override));
};
} // namespace webrtc
@ -45,13 +45,15 @@ namespace webrtc {
class MockExpandFactory : public ExpandFactory {
public:
MOCK_CONST_METHOD6(Create,
Expand*(BackgroundNoise* background_noise,
SyncBuffer* sync_buffer,
RandomVector* random_vector,
StatisticsCalculator* statistics,
int fs,
size_t num_channels));
MOCK_METHOD(Expand*,
Create,
(BackgroundNoise * background_noise,
SyncBuffer* sync_buffer,
RandomVector* random_vector,
StatisticsCalculator* statistics,
int fs,
size_t num_channels),
(const, override));
};
} // namespace webrtc

4
modules/audio_coding/neteq/mock/mock_histogram.h
View File

@ -22,8 +22,8 @@ class MockHistogram : public Histogram {
: Histogram(num_buckets, forget_factor) {}
virtual ~MockHistogram() {}
MOCK_METHOD1(Add, void(int));
MOCK_METHOD1(Quantile, int(int));
MOCK_METHOD(void, Add, (int), (override));
MOCK_METHOD(int, Quantile, (int), (override));
};
} // namespace webrtc

79
modules/audio_coding/neteq/mock/mock_neteq_controller.h
View File

@ -19,46 +19,45 @@ namespace webrtc {
class MockNetEqController : public NetEqController {
public:
MockNetEqController() = default;
virtual ~MockNetEqController() { Die(); }
MOCK_METHOD0(Die, void());
MOCK_METHOD0(Reset, void());
MOCK_METHOD0(SoftReset, void());
MOCK_METHOD2(GetDecision,
NetEq::Operation(const NetEqStatus& neteq_status,
bool* reset_decoder));
MOCK_METHOD6(Update,
void(uint16_t sequence_number,
uint32_t timestamp,
uint32_t last_played_out_timestamp,
bool new_codec,
bool cng_or_dtmf,
size_t packet_length_samples));
MOCK_METHOD0(RegisterEmptyPacket, void());
MOCK_METHOD2(SetSampleRate, void(int fs_hz, size_t output_size_samples));
MOCK_METHOD1(SetMaximumDelay, bool(int delay_ms));
MOCK_METHOD1(SetMinimumDelay, bool(int delay_ms));
MOCK_METHOD1(SetBaseMinimumDelay, bool(int delay_ms));
MOCK_CONST_METHOD0(GetBaseMinimumDelay, int());
MOCK_CONST_METHOD0(CngRfc3389On, bool());
MOCK_CONST_METHOD0(CngOff, bool());
MOCK_METHOD0(SetCngOff, void());
MOCK_METHOD1(ExpandDecision, void(NetEq::Operation operation));
MOCK_METHOD1(AddSampleMemory, void(int32_t value));
MOCK_METHOD0(TargetLevelMs, int());
MOCK_METHOD6(PacketArrived,
absl::optional<int>(bool last_cng_or_dtmf,
size_t packet_length_samples,
bool should_update_stats,
uint16_t main_sequence_number,
uint32_t main_timestamp,
int fs_hz));
MOCK_CONST_METHOD0(PeakFound, bool());
MOCK_CONST_METHOD0(GetFilteredBufferLevel, int());
MOCK_METHOD1(set_sample_memory, void(int32_t value));
MOCK_CONST_METHOD0(noise_fast_forward, size_t());
MOCK_CONST_METHOD0(packet_length_samples, size_t());
MOCK_METHOD1(set_packet_length_samples, void(size_t value));
MOCK_METHOD1(set_prev_time_scale, void(bool value));
~MockNetEqController() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD(void, Reset, (), (override));
MOCK_METHOD(void, SoftReset, (), (override));
MOCK_METHOD(NetEq::Operation,
GetDecision,
(const NetEqStatus& neteq_status, bool* reset_decoder),
(override));
MOCK_METHOD(void, RegisterEmptyPacket, (), (override));
MOCK_METHOD(void,
SetSampleRate,
(int fs_hz, size_t output_size_samples),
(override));
MOCK_METHOD(bool, SetMaximumDelay, (int delay_ms), (override));
MOCK_METHOD(bool, SetMinimumDelay, (int delay_ms), (override));
MOCK_METHOD(bool, SetBaseMinimumDelay, (int delay_ms), (override));
MOCK_METHOD(int, GetBaseMinimumDelay, (), (const, override));
MOCK_METHOD(bool, CngRfc3389On, (), (const, override));
MOCK_METHOD(bool, CngOff, (), (const, override));
MOCK_METHOD(void, SetCngOff, (), (override));
MOCK_METHOD(void, ExpandDecision, (NetEq::Operation operation), (override));
MOCK_METHOD(void, AddSampleMemory, (int32_t value), (override));
MOCK_METHOD(int, TargetLevelMs, (), (override));
MOCK_METHOD(absl::optional<int>,
PacketArrived,
(bool last_cng_or_dtmf,
size_t packet_length_samples,
bool should_update_stats,
uint16_t main_sequence_number,
uint32_t main_timestamp,
int fs_hz),
(override));
MOCK_METHOD(bool, PeakFound, (), (const, override));
MOCK_METHOD(int, GetFilteredBufferLevel, (), (const, override));
MOCK_METHOD(void, set_sample_memory, (int32_t value), (override));
MOCK_METHOD(size_t, noise_fast_forward, (), (const, override));
MOCK_METHOD(size_t, packet_length_samples, (), (const, override));
MOCK_METHOD(void, set_packet_length_samples, (size_t value), (override));
MOCK_METHOD(void, set_prev_time_scale, (bool value), (override));
};
} // namespace webrtc

74
modules/audio_coding/neteq/mock/mock_packet_buffer.h
View File

@ -20,39 +20,47 @@ class MockPacketBuffer : public PacketBuffer {
public:
MockPacketBuffer(size_t max_number_of_packets, const TickTimer* tick_timer)
: PacketBuffer(max_number_of_packets, tick_timer) {}
virtual ~MockPacketBuffer() { Die(); }
MOCK_METHOD0(Die, void());
MOCK_METHOD0(Flush, void());
MOCK_CONST_METHOD0(Empty, bool());
int InsertPacket(Packet&& packet, StatisticsCalculator* stats) {
return InsertPacketWrapped(&packet, stats);
}
// Since gtest does not properly support move-only types, InsertPacket is
// implemented as a wrapper. You'll have to implement InsertPacketWrapped
// instead and move from |*packet|.
MOCK_METHOD2(InsertPacketWrapped,
int(Packet* packet, StatisticsCalculator* stats));
MOCK_METHOD5(InsertPacketList,
int(PacketList* packet_list,
const DecoderDatabase& decoder_database,
absl::optional<uint8_t>* current_rtp_payload_type,
absl::optional<uint8_t>* current_cng_rtp_payload_type,
StatisticsCalculator* stats));
MOCK_CONST_METHOD1(NextTimestamp, int(uint32_t* next_timestamp));
MOCK_CONST_METHOD2(NextHigherTimestamp,
int(uint32_t timestamp, uint32_t* next_timestamp));
MOCK_CONST_METHOD0(PeekNextPacket, const Packet*());
MOCK_METHOD0(GetNextPacket, absl::optional<Packet>());
MOCK_METHOD1(DiscardNextPacket, int(StatisticsCalculator* stats));
MOCK_METHOD3(DiscardOldPackets,
void(uint32_t timestamp_limit,
uint32_t horizon_samples,
StatisticsCalculator* stats));
MOCK_METHOD2(DiscardAllOldPackets,
void(uint32_t timestamp_limit, StatisticsCalculator* stats));
MOCK_CONST_METHOD0(NumPacketsInBuffer, size_t());
MOCK_METHOD1(IncrementWaitingTimes, void(int));
MOCK_CONST_METHOD0(current_memory_bytes, int());
~MockPacketBuffer() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD(void, Flush, (), (override));
MOCK_METHOD(bool, Empty, (), (const, override));
MOCK_METHOD(int,
InsertPacket,
(Packet && packet, StatisticsCalculator* stats),
(override));
MOCK_METHOD(int,
InsertPacketList,
(PacketList * packet_list,
const DecoderDatabase& decoder_database,
absl::optional<uint8_t>* current_rtp_payload_type,
absl::optional<uint8_t>* current_cng_rtp_payload_type,
StatisticsCalculator* stats),
(override));
MOCK_METHOD(int,
NextTimestamp,
(uint32_t * next_timestamp),
(const, override));
MOCK_METHOD(int,
NextHigherTimestamp,
(uint32_t timestamp, uint32_t* next_timestamp),
(const, override));
MOCK_METHOD(const Packet*, PeekNextPacket, (), (const, override));
MOCK_METHOD(absl::optional<Packet>, GetNextPacket, (), (override));
MOCK_METHOD(int,
DiscardNextPacket,
(StatisticsCalculator * stats),
(override));
MOCK_METHOD(void,
DiscardOldPackets,
(uint32_t timestamp_limit,
uint32_t horizon_samples,
StatisticsCalculator* stats),
(override));
MOCK_METHOD(void,
DiscardAllOldPackets,
(uint32_t timestamp_limit, StatisticsCalculator* stats),
(override));
MOCK_METHOD(size_t, NumPacketsInBuffer, (), (const, override));
};
} // namespace webrtc

10
modules/audio_coding/neteq/mock/mock_red_payload_splitter.h
View File

@ -18,10 +18,12 @@ namespace webrtc {
class MockRedPayloadSplitter : public RedPayloadSplitter {
public:
MOCK_METHOD1(SplitRed, bool(PacketList* packet_list));
MOCK_METHOD2(CheckRedPayloads,
void(PacketList* packet_list,
const DecoderDatabase& decoder_database));
MOCK_METHOD(bool, SplitRed, (PacketList * packet_list), (override));
MOCK_METHOD(void,
CheckRedPayloads,
(PacketList * packet_list,
const DecoderDatabase& decoder_database),
(override));
};
} // namespace webrtc

9
modules/audio_coding/neteq/mock/mock_statistics_calculator.h
View File

@ -18,9 +18,12 @@ namespace webrtc {
class MockStatisticsCalculator : public StatisticsCalculator {
public:
MOCK_METHOD1(PacketsDiscarded, void(size_t num_packets));
MOCK_METHOD1(SecondaryPacketsDiscarded, void(size_t num_packets));
MOCK_METHOD1(RelativePacketArrivalDelay, void(size_t delay_ms));
MOCK_METHOD(void, PacketsDiscarded, (size_t num_packets), (override));
MOCK_METHOD(void,
SecondaryPacketsDiscarded,
(size_t num_packets),
(override));
MOCK_METHOD(void, RelativePacketArrivalDelay, (size_t delay_ms), (override));
};
} // namespace webrtc

6
modules/audio_coding/neteq/neteq_network_stats_unittest.cc
View File

@ -52,10 +52,10 @@ class MockAudioDecoder final : public AudioDecoder {
: sample_rate_hz_(sample_rate_hz),
num_channels_(num_channels),
fec_enabled_(false) {}
~MockAudioDecoder() /* override */ { Die(); }
MOCK_METHOD0(Die, void());
~MockAudioDecoder() override { Die(); }
MOCK_METHOD(void, Die, ());
MOCK_METHOD0(Reset, void());
MOCK_METHOD(void, Reset, (), (override));
class MockFrame : public AudioDecoder::EncodedAudioFrame {
public:

11
modules/audio_coding/neteq/packet_buffer_unittest.cc
View File

@ -31,13 +31,14 @@ using ::testing::StrictMock;
namespace {
class MockEncodedAudioFrame : public webrtc::AudioDecoder::EncodedAudioFrame {
public:
MOCK_CONST_METHOD0(Duration, size_t());
MOCK_METHOD(size_t, Duration, (), (const, override));
MOCK_CONST_METHOD0(IsDtxPacket, bool());
MOCK_METHOD(bool, IsDtxPacket, (), (const, override));
MOCK_CONST_METHOD1(
Decode,
absl::optional<DecodeResult>(rtc::ArrayView<int16_t> decoded));
MOCK_METHOD(absl::optional<DecodeResult>,
Decode,
(rtc::ArrayView<int16_t> decoded),
(const, override));
};
// Helper class to generate packets. Packets must be deleted by the user.