mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-12 21:30:45 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

In test/ replace mock macros with unified MOCK_METHOD macro

Browse source 
Bug: webrtc:11564
Change-Id: I75496d2f9f5612c4677057ce6fab2a55efa8674a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/175129
Reviewed-by: Artem Titov <titovartem@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31267}
This commit is contained in:
Danil Chapovalov 2020-05-14 19:50:01 +02:00 committed by Commit Bot
parent 42748d8e22
commit 54706d68f6
8 changed files with 81 additions and 62 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
test/frame_generator_capturer_unittest.cc
View file

@ -22,8 +22,8 @@ using ::testing::Property;
class MockVideoSinkInterfaceVideoFrame
: public rtc::VideoSinkInterface<VideoFrame> {
public:
MOCK_METHOD1(OnFrame, void(const VideoFrame& frame));
MOCK_METHOD0(OnDiscardedFrame, void());
MOCK_METHOD(void, OnFrame, (const VideoFrame& frame), (override));
MOCK_METHOD(void, OnDiscardedFrame, (), (override));
};
} // namespace
TEST(FrameGeneratorCapturerTest, CreateFromConfig) {

22
test/mock_audio_decoder.h
View file

@ -20,16 +20,18 @@ class MockAudioDecoder : public AudioDecoder {
public:
MockAudioDecoder();
~MockAudioDecoder();
MOCK_METHOD0(Die, void());
MOCK_METHOD5(DecodeInternal,
int(const uint8_t*, size_t, int, int16_t*, SpeechType*));
MOCK_CONST_METHOD0(HasDecodePlc, bool());
MOCK_METHOD2(DecodePlc, size_t(size_t, int16_t*));
MOCK_METHOD0(Reset, void());
MOCK_METHOD0(ErrorCode, int());
MOCK_CONST_METHOD2(PacketDuration, int(const uint8_t*, size_t));
MOCK_CONST_METHOD0(Channels, size_t());
MOCK_CONST_METHOD0(SampleRateHz, int());
MOCK_METHOD(void, Die, ());
MOCK_METHOD(int,
DecodeInternal,
(const uint8_t*, size_t, int, int16_t*, SpeechType*),
(override));
MOCK_METHOD(bool, HasDecodePlc, (), (const, override));
MOCK_METHOD(size_t, DecodePlc, (size_t, int16_t*), (override));
MOCK_METHOD(void, Reset, (), (override));
MOCK_METHOD(int, ErrorCode, (), (override));
MOCK_METHOD(int, PacketDuration, (const uint8_t*, size_t), (const, override));
MOCK_METHOD(size_t, Channels, (), (const, override));
MOCK_METHOD(int, SampleRateHz, (), (const, override));
};
} // namespace webrtc

18
test/mock_audio_decoder_factory.h
View file

@ -24,19 +24,23 @@ namespace webrtc {
class MockAudioDecoderFactory : public AudioDecoderFactory {
public:
MOCK_METHOD0(GetSupportedDecoders, std::vector<AudioCodecSpec>());
MOCK_METHOD1(IsSupportedDecoder, bool(const SdpAudioFormat&));
MOCK_METHOD(std::vector<AudioCodecSpec>,
GetSupportedDecoders,
(),
(override));
MOCK_METHOD(bool, IsSupportedDecoder, (const SdpAudioFormat&), (override));
std::unique_ptr<AudioDecoder> MakeAudioDecoder(
const SdpAudioFormat& format,
absl::optional<AudioCodecPairId> codec_pair_id) {
absl::optional<AudioCodecPairId> codec_pair_id) override {
std::unique_ptr<AudioDecoder> return_value;
MakeAudioDecoderMock(format, codec_pair_id, &return_value);
return return_value;
}
MOCK_METHOD3(MakeAudioDecoderMock,
void(const SdpAudioFormat& format,
absl::optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioDecoder>* return_value));
MOCK_METHOD(void,
MakeAudioDecoderMock,
(const SdpAudioFormat& format,
absl::optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioDecoder>*));
// Creates a MockAudioDecoderFactory with no formats and that may not be
// invoked to create a codec - useful for initializing a voice engine, for

61
test/mock_audio_encoder.h
View file

@ -27,37 +27,44 @@ class MockAudioEncoder : public AudioEncoder {
// http://crbug.com/428099.
MockAudioEncoder();
~MockAudioEncoder();
MOCK_METHOD1(Mark, void(std::string desc));
MOCK_CONST_METHOD0(SampleRateHz, int());
MOCK_CONST_METHOD0(NumChannels, size_t());
MOCK_CONST_METHOD0(RtpTimestampRateHz, int());
MOCK_CONST_METHOD0(Num10MsFramesInNextPacket, size_t());
MOCK_CONST_METHOD0(Max10MsFramesInAPacket, size_t());
MOCK_CONST_METHOD0(GetTargetBitrate, int());
MOCK_CONST_METHOD0(GetFrameLengthRange,
absl::optional<std::pair<TimeDelta, TimeDelta>>());
MOCK_METHOD(int, SampleRateHz, (), (const, override));
MOCK_METHOD(size_t, NumChannels, (), (const, override));
MOCK_METHOD(int, RtpTimestampRateHz, (), (const, override));
MOCK_METHOD(size_t, Num10MsFramesInNextPacket, (), (const, override));
MOCK_METHOD(size_t, Max10MsFramesInAPacket, (), (const, override));
MOCK_METHOD(int, GetTargetBitrate, (), (const, override));
MOCK_METHOD((absl::optional<std::pair<TimeDelta, TimeDelta>>),
GetFrameLengthRange,
(),
(const, override));
MOCK_METHOD0(Reset, void());
MOCK_METHOD1(SetFec, bool(bool enable));
MOCK_METHOD1(SetDtx, bool(bool enable));
MOCK_METHOD1(SetApplication, bool(Application application));
MOCK_METHOD1(SetMaxPlaybackRate, void(int frequency_hz));
MOCK_METHOD1(SetMaxBitrate, void(int max_bps));
MOCK_METHOD1(SetMaxPayloadSize, void(int max_payload_size_bytes));
MOCK_METHOD2(OnReceivedUplinkBandwidth,
void(int target_audio_bitrate_bps,
absl::optional<int64_t> probing_interval_ms));
MOCK_METHOD1(OnReceivedUplinkPacketLossFraction,
void(float uplink_packet_loss_fraction));
MOCK_METHOD(void, Reset, (), (override));
MOCK_METHOD(bool, SetFec, (bool enable), (override));
MOCK_METHOD(bool, SetDtx, (bool enable), (override));
MOCK_METHOD(bool, SetApplication, (Application application), (override));
MOCK_METHOD(void, SetMaxPlaybackRate, (int frequency_hz), (override));
MOCK_METHOD(void,
OnReceivedUplinkBandwidth,
(int target_audio_bitrate_bps,
absl::optional<int64_t> probing_interval_ms),
(override));
MOCK_METHOD(void,
OnReceivedUplinkPacketLossFraction,
(float uplink_packet_loss_fraction),
(override));
MOCK_METHOD2(EnableAudioNetworkAdaptor,
bool(const std::string& config_string, RtcEventLog* event_log));
MOCK_METHOD(bool,
EnableAudioNetworkAdaptor,
(const std::string& config_string, RtcEventLog*),
(override));
// Note, we explicitly chose not to create a mock for the Encode method.
MOCK_METHOD3(EncodeImpl,
EncodedInfo(uint32_t timestamp,
rtc::ArrayView<const int16_t> audio,
rtc::Buffer* encoded));
MOCK_METHOD(EncodedInfo,
EncodeImpl,
(uint32_t timestamp,
rtc::ArrayView<const int16_t> audio,
rtc::Buffer*),
(override));
class FakeEncoding {
public:

24
test/mock_audio_encoder_factory.h
View file

@ -24,23 +24,29 @@ namespace webrtc {
class MockAudioEncoderFactory
: public ::testing::NiceMock<AudioEncoderFactory> {
public:
MOCK_METHOD0(GetSupportedEncoders, std::vector<AudioCodecSpec>());
MOCK_METHOD1(QueryAudioEncoder,
absl::optional<AudioCodecInfo>(const SdpAudioFormat& format));
MOCK_METHOD(std::vector<AudioCodecSpec>,
GetSupportedEncoders,
(),
(override));
MOCK_METHOD(absl::optional<AudioCodecInfo>,
QueryAudioEncoder,
(const SdpAudioFormat& format),
(override));
std::unique_ptr<AudioEncoder> MakeAudioEncoder(
int payload_type,
const SdpAudioFormat& format,
absl::optional<AudioCodecPairId> codec_pair_id) {
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_METHOD4(MakeAudioEncoderMock,
void(int payload_type,
const SdpAudioFormat& format,
absl::optional<AudioCodecPairId> codec_pair_id,
std::unique_ptr<AudioEncoder>* 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
// invoked to create a codec - useful for initializing a voice engine, for

2
test/mock_transport.h
View file

@ -25,7 +25,7 @@ class MockTransport : public Transport {
SendRtp,
(const uint8_t*, size_t, const PacketOptions&),
(override));
MOCK_METHOD(bool, SendRtcp, (const uint8_t* data, size_t len), (override));
MOCK_METHOD(bool, SendRtcp, (const uint8_t*, size_t len), (override));
};
} // namespace webrtc

2
test/network/network_emulation_unittest.cc
View file

@ -70,7 +70,7 @@ class SocketReader : public sigslot::has_slots<> {
class MockReceiver : public EmulatedNetworkReceiverInterface {
public:
MOCK_METHOD1(OnPacketReceived, void(EmulatedIpPacket packet));
MOCK_METHOD(void, OnPacketReceived, (EmulatedIpPacket packet), (override));
};
class NetworkEmulationManagerThreeNodesRoutingTest : public ::testing::Test {

10
test/testsupport/mock/mock_frame_reader.h
View file

@ -19,11 +19,11 @@ namespace test {
class MockFrameReader : public FrameReader {
public:
MOCK_METHOD0(Init, bool());
MOCK_METHOD0(ReadFrame, rtc::scoped_refptr<I420Buffer>());
MOCK_METHOD0(Close, void());
MOCK_METHOD0(FrameLength, size_t());
MOCK_METHOD0(NumberOfFrames, int());
MOCK_METHOD(bool, Init, (), (override));
MOCK_METHOD(rtc::scoped_refptr<I420Buffer>, ReadFrame, (), (override));
MOCK_METHOD(void, Close, (), (override));
MOCK_METHOD(size_t, FrameLength, (), (override));
MOCK_METHOD(int, NumberOfFrames, (), (override));
};
} // namespace test