mollyim/webrtc
1
0
Fork 0
mirror of https://github.com/mollyim/webrtc.git synced 2025-05-13 05:40:42 +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 class MockVideoSinkInterfaceVideoFrame
: public rtc::VideoSinkInterface<VideoFrame> { : public rtc::VideoSinkInterface<VideoFrame> {
public: public:
MOCK_METHOD1(OnFrame, void(const VideoFrame& frame)); MOCK_METHOD(void, OnFrame, (const VideoFrame& frame), (override));
MOCK_METHOD0(OnDiscardedFrame, void()); MOCK_METHOD(void, OnDiscardedFrame, (), (override));
}; };
} // namespace } // namespace
TEST(FrameGeneratorCapturerTest, CreateFromConfig) { TEST(FrameGeneratorCapturerTest, CreateFromConfig) {

22
test/mock_audio_decoder.h
View file

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

18
test/mock_audio_decoder_factory.h
View file

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

61
test/mock_audio_encoder.h
View file

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

24
test/mock_audio_encoder_factory.h
View file

@ -24,23 +24,29 @@ namespace webrtc {
class MockAudioEncoderFactory class MockAudioEncoderFactory
: public ::testing::NiceMock<AudioEncoderFactory> { : public ::testing::NiceMock<AudioEncoderFactory> {
public: public:
MOCK_METHOD0(GetSupportedEncoders, std::vector<AudioCodecSpec>()); MOCK_METHOD(std::vector<AudioCodecSpec>,
MOCK_METHOD1(QueryAudioEncoder, GetSupportedEncoders,
absl::optional<AudioCodecInfo>(const SdpAudioFormat& format)); (),
(override));
MOCK_METHOD(absl::optional<AudioCodecInfo>,
QueryAudioEncoder,
(const SdpAudioFormat& format),
(override));
std::unique_ptr<AudioEncoder> MakeAudioEncoder( std::unique_ptr<AudioEncoder> MakeAudioEncoder(
int payload_type, int payload_type,
const SdpAudioFormat& format, const SdpAudioFormat& format,
absl::optional<AudioCodecPairId> codec_pair_id) { absl::optional<AudioCodecPairId> codec_pair_id) override {
std::unique_ptr<AudioEncoder> return_value; std::unique_ptr<AudioEncoder> return_value;
MakeAudioEncoderMock(payload_type, format, codec_pair_id, &return_value); MakeAudioEncoderMock(payload_type, format, codec_pair_id, &return_value);
return return_value; return return_value;
} }
MOCK_METHOD4(MakeAudioEncoderMock, MOCK_METHOD(void,
void(int payload_type, MakeAudioEncoderMock,
const SdpAudioFormat& format, (int payload_type,
absl::optional<AudioCodecPairId> codec_pair_id, const SdpAudioFormat& format,
std::unique_ptr<AudioEncoder>* return_value)); 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

2
test/mock_transport.h
View file

@ -25,7 +25,7 @@ class MockTransport : public Transport {
SendRtp, SendRtp,
(const uint8_t*, size_t, const PacketOptions&), (const uint8_t*, size_t, const PacketOptions&),
(override)); (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 } // 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 { class MockReceiver : public EmulatedNetworkReceiverInterface {
public: public:
MOCK_METHOD1(OnPacketReceived, void(EmulatedIpPacket packet)); MOCK_METHOD(void, OnPacketReceived, (EmulatedIpPacket packet), (override));
}; };
class NetworkEmulationManagerThreeNodesRoutingTest : public ::testing::Test { 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 { class MockFrameReader : public FrameReader {
public: public:
MOCK_METHOD0(Init, bool()); MOCK_METHOD(bool, Init, (), (override));
MOCK_METHOD0(ReadFrame, rtc::scoped_refptr<I420Buffer>()); MOCK_METHOD(rtc::scoped_refptr<I420Buffer>, ReadFrame, (), (override));
MOCK_METHOD0(Close, void()); MOCK_METHOD(void, Close, (), (override));
MOCK_METHOD0(FrameLength, size_t()); MOCK_METHOD(size_t, FrameLength, (), (override));
MOCK_METHOD0(NumberOfFrames, int()); MOCK_METHOD(int, NumberOfFrames, (), (override));
}; };
} // namespace test } // namespace test