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 rtc_base/ and api/ replace mock macros with unified MOCK_METHOD macro

Browse source 
Bug: webrtc:11564
Change-Id: I8f4171490df39c683276f9d401a4083962ee409a
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/175130
Reviewed-by: Karl Wiberg <kwiberg@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31266}
This commit is contained in:
Danil Chapovalov 2020-05-14 20:42:41 +02:00 committed by Commit Bot
parent cdc89b4d14
commit 42748d8e22
12 changed files with 107 additions and 76 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
api/test/loopback_media_transport_unittest.cc
View file

@ -23,33 +23,41 @@ namespace {
class MockMediaTransportAudioSinkInterface class MockMediaTransportAudioSinkInterface
: public MediaTransportAudioSinkInterface { : public MediaTransportAudioSinkInterface {
public: public:
MOCK_METHOD2(OnData, void(uint64_t, MediaTransportEncodedAudioFrame)); MOCK_METHOD(void,
OnData,
(uint64_t, MediaTransportEncodedAudioFrame),
(override));
}; };
class MockMediaTransportVideoSinkInterface class MockMediaTransportVideoSinkInterface
: public MediaTransportVideoSinkInterface { : public MediaTransportVideoSinkInterface {
public: public:
MOCK_METHOD2(OnData, void(uint64_t, MediaTransportEncodedVideoFrame)); MOCK_METHOD(void,
OnData,
(uint64_t, MediaTransportEncodedVideoFrame),
(override));
}; };
class MockMediaTransportKeyFrameRequestCallback class MockMediaTransportKeyFrameRequestCallback
: public MediaTransportKeyFrameRequestCallback { : public MediaTransportKeyFrameRequestCallback {
public: public:
MOCK_METHOD1(OnKeyFrameRequested, void(uint64_t)); MOCK_METHOD(void, OnKeyFrameRequested, (uint64_t), (override));
}; };
class MockDataChannelSink : public DataChannelSink { class MockDataChannelSink : public DataChannelSink {
public: public:
MOCK_METHOD3(OnDataReceived, MOCK_METHOD(void,
void(int, DataMessageType, const rtc::CopyOnWriteBuffer&)); OnDataReceived,
MOCK_METHOD1(OnChannelClosing, void(int)); (int, DataMessageType, const rtc::CopyOnWriteBuffer&),
MOCK_METHOD1(OnChannelClosed, void(int)); (override));
MOCK_METHOD0(OnReadyToSend, void()); MOCK_METHOD(void, OnChannelClosing, (int), (override));
MOCK_METHOD(void, OnChannelClosed, (int), (override));
MOCK_METHOD(void, OnReadyToSend, (), (override));
}; };
class MockStateCallback : public MediaTransportStateCallback { class MockStateCallback : public MediaTransportStateCallback {
public: public:
MOCK_METHOD1(OnStateChanged, void(MediaTransportState)); MOCK_METHOD(void, OnStateChanged, (MediaTransportState), (override));
}; };
} // namespace } // namespace

9
api/test/mock_audio_mixer.h
View file

@ -19,12 +19,9 @@ namespace test {
class MockAudioMixer : public AudioMixer { class MockAudioMixer : public AudioMixer {
public: public:
MOCK_METHOD(bool, AddSource, (Source * audio_source), (override)); MOCK_METHOD(bool, AddSource, (Source*), (override));
MOCK_METHOD(void, RemoveSource, (Source * audio_source), (override)); MOCK_METHOD(void, RemoveSource, (Source*), (override));
MOCK_METHOD(void, MOCK_METHOD(void, Mix, (size_t number_of_channels, AudioFrame*), (override));
Mix,
(size_t number_of_channels, AudioFrame* audio_frame_for_mixing),
(override));
}; };
} // namespace test } // namespace test
} // namespace webrtc } // namespace webrtc

2
api/test/mock_video_bitrate_allocator_factory.h
View file

@ -26,7 +26,7 @@ class MockVideoBitrateAllocatorFactory
CreateVideoBitrateAllocator, CreateVideoBitrateAllocator,
(const VideoCodec&), (const VideoCodec&),
(override)); (override));
MOCK_METHOD(void, Die, (), ()); MOCK_METHOD(void, Die, ());
}; };
} // namespace webrtc } // namespace webrtc

4
api/test/mock_video_decoder_factory.h
View file

@ -27,12 +27,12 @@ class MockVideoDecoderFactory : public webrtc::VideoDecoderFactory {
MOCK_METHOD(std::vector<webrtc::SdpVideoFormat>, MOCK_METHOD(std::vector<webrtc::SdpVideoFormat>,
GetSupportedFormats, GetSupportedFormats,
(), (),
(const override)); (const, override));
MOCK_METHOD(std::unique_ptr<webrtc::VideoDecoder>, MOCK_METHOD(std::unique_ptr<webrtc::VideoDecoder>,
CreateVideoDecoder, CreateVideoDecoder,
(const webrtc::SdpVideoFormat&), (const webrtc::SdpVideoFormat&),
(override)); (override));
MOCK_METHOD(void, Die, (), ()); MOCK_METHOD(void, Die, ());
}; };
} // namespace webrtc } // namespace webrtc

54
api/test/mock_video_encoder.h
View file

@ -23,8 +23,8 @@ class MockEncodedImageCallback : public EncodedImageCallback {
MOCK_METHOD(Result, MOCK_METHOD(Result,
OnEncodedImage, OnEncodedImage,
(const EncodedImage& encodedImage, (const EncodedImage& encodedImage,
const CodecSpecificInfo* codecSpecificInfo, const CodecSpecificInfo*,
const RTPFragmentationHeader* fragmentation), const RTPFragmentationHeader*),
(override)); (override));
MOCK_METHOD(void, OnDroppedFrame, (DropReason reason), (override)); MOCK_METHOD(void, OnDroppedFrame, (DropReason reason), (override));
}; };
@ -33,31 +33,41 @@ class MockVideoEncoder : public VideoEncoder {
public: public:
MOCK_METHOD(void, MOCK_METHOD(void,
SetFecControllerOverride, SetFecControllerOverride,
(FecControllerOverride * fec_controller_override), (FecControllerOverride*),
(override)); (override));
MOCK_METHOD(int32_t, MOCK_METHOD(int32_t,
InitEncode, InitEncode,
(const VideoCodec* codecSettings, (const VideoCodec*, int32_t numberOfCores, size_t maxPayloadSize),
int32_t numberOfCores, (override));
size_t maxPayloadSize), MOCK_METHOD(int32_t,
InitEncode,
(const VideoCodec*, const VideoEncoder::Settings& settings),
(override)); (override));
MOCK_METHOD2(InitEncode,
int32_t(const VideoCodec* codecSettings,
const VideoEncoder::Settings& settings));
MOCK_METHOD2(Encode, MOCK_METHOD(int32_t,
int32_t(const VideoFrame& inputImage, Encode,
const std::vector<VideoFrameType>* frame_types)); (const VideoFrame& inputImage,
MOCK_METHOD1(RegisterEncodeCompleteCallback, const std::vector<VideoFrameType>*),
int32_t(EncodedImageCallback* callback)); (override));
MOCK_METHOD0(Release, int32_t()); MOCK_METHOD(int32_t,
MOCK_METHOD0(Reset, int32_t()); RegisterEncodeCompleteCallback,
MOCK_METHOD1(SetRates, void(const RateControlParameters& parameters)); (EncodedImageCallback*),
MOCK_METHOD1(OnPacketLossRateUpdate, void(float packet_loss_rate)); (override));
MOCK_METHOD1(OnRttUpdate, void(int64_t rtt_ms)); MOCK_METHOD(int32_t, Release, (), (override));
MOCK_METHOD1(OnLossNotification, MOCK_METHOD(void,
void(const LossNotification& loss_notification)); SetRates,
MOCK_CONST_METHOD0(GetEncoderInfo, EncoderInfo(void)); (const RateControlParameters& parameters),
(override));
MOCK_METHOD(void,
OnPacketLossRateUpdate,
(float packet_loss_rate),
(override));
MOCK_METHOD(void, OnRttUpdate, (int64_t rtt_ms), (override));
MOCK_METHOD(void,
OnLossNotification,
(const LossNotification& loss_notification),
(override));
MOCK_METHOD(EncoderInfo, GetEncoderInfo, (), (const, override));
}; };
} // namespace webrtc } // namespace webrtc

6
api/test/mock_video_encoder_factory.h
View file

@ -27,17 +27,17 @@ class MockVideoEncoderFactory : public webrtc::VideoEncoderFactory {
MOCK_METHOD(std::vector<SdpVideoFormat>, MOCK_METHOD(std::vector<SdpVideoFormat>,
GetSupportedFormats, GetSupportedFormats,
(), (),
(const override)); (const, override));
MOCK_METHOD(CodecInfo, MOCK_METHOD(CodecInfo,
QueryVideoEncoder, QueryVideoEncoder,
(const SdpVideoFormat&), (const SdpVideoFormat&),
(const override)); (const, override));
MOCK_METHOD(std::unique_ptr<VideoEncoder>, MOCK_METHOD(std::unique_ptr<VideoEncoder>,
CreateVideoEncoder, CreateVideoEncoder,
(const SdpVideoFormat&), (const SdpVideoFormat&),
(override)); (override));
MOCK_METHOD(void, Die, (), ()); MOCK_METHOD(void, Die, ());
}; };
} // namespace webrtc } // namespace webrtc

15
api/transport/test/mock_network_control.h
View file

@ -18,11 +18,16 @@ namespace webrtc {
class MockNetworkStateEstimator : public NetworkStateEstimator { class MockNetworkStateEstimator : public NetworkStateEstimator {
public: public:
MOCK_METHOD0(GetCurrentEstimate, absl::optional<NetworkStateEstimate>()); MOCK_METHOD(absl::optional<NetworkStateEstimate>,
MOCK_METHOD1(OnTransportPacketsFeedback, GetCurrentEstimate,
void(const TransportPacketsFeedback&)); (),
MOCK_METHOD1(OnReceivedPacket, void(const PacketResult&)); (override));
MOCK_METHOD1(OnRouteChange, void(const NetworkRouteChange&)); MOCK_METHOD(void,
OnTransportPacketsFeedback,
(const TransportPacketsFeedback&),
(override));
MOCK_METHOD(void, OnReceivedPacket, (const PacketResult&), (override));
MOCK_METHOD(void, OnRouteChange, (const NetworkRouteChange&), (override));
}; };
} // namespace webrtc } // namespace webrtc

19
api/video/test/mock_recordable_encoded_frame.h
View file

@ -17,13 +17,18 @@
namespace webrtc { namespace webrtc {
class MockRecordableEncodedFrame : public RecordableEncodedFrame { class MockRecordableEncodedFrame : public RecordableEncodedFrame {
public: public:
MOCK_CONST_METHOD0(encoded_buffer, MOCK_METHOD(rtc::scoped_refptr<const EncodedImageBufferInterface>,
rtc::scoped_refptr<const EncodedImageBufferInterface>()); encoded_buffer,
MOCK_CONST_METHOD0(color_space, absl::optional<webrtc::ColorSpace>()); (),
MOCK_CONST_METHOD0(codec, VideoCodecType()); (const, override));
MOCK_CONST_METHOD0(is_key_frame, bool()); MOCK_METHOD(absl::optional<webrtc::ColorSpace>,
MOCK_CONST_METHOD0(resolution, EncodedResolution()); color_space,
MOCK_CONST_METHOD0(render_time, Timestamp()); (),
(const, override));
MOCK_METHOD(VideoCodecType, codec, (), (const, override));
MOCK_METHOD(bool, is_key_frame, (), (const, override));
MOCK_METHOD(EncodedResolution, resolution, (), (const, override));
MOCK_METHOD(Timestamp, render_time, (), (const, override));
}; };
} // namespace webrtc } // namespace webrtc
#endif // API_VIDEO_TEST_MOCK_RECORDABLE_ENCODED_FRAME_H_ #endif // API_VIDEO_TEST_MOCK_RECORDABLE_ENCODED_FRAME_H_

40
rtc_base/openssl_adapter_unittest.cc
View file

@ -25,28 +25,34 @@ namespace {
class MockAsyncSocket : public AsyncSocket { class MockAsyncSocket : public AsyncSocket {
public: public:
virtual ~MockAsyncSocket() = default; virtual ~MockAsyncSocket() = default;
MOCK_METHOD1(Accept, AsyncSocket*(SocketAddress*)); MOCK_METHOD(AsyncSocket*, Accept, (SocketAddress*), (override));
MOCK_CONST_METHOD0(GetLocalAddress, SocketAddress()); MOCK_METHOD(SocketAddress, GetLocalAddress, (), (const, override));
MOCK_CONST_METHOD0(GetRemoteAddress, SocketAddress()); MOCK_METHOD(SocketAddress, GetRemoteAddress, (), (const, override));
MOCK_METHOD1(Bind, int(const SocketAddress&)); MOCK_METHOD(int, Bind, (const SocketAddress&), (override));
MOCK_METHOD1(Connect, int(const SocketAddress&)); MOCK_METHOD(int, Connect, (const SocketAddress&), (override));
MOCK_METHOD2(Send, int(const void*, size_t)); MOCK_METHOD(int, Send, (const void*, size_t), (override));
MOCK_METHOD3(SendTo, int(const void*, size_t, const SocketAddress&)); MOCK_METHOD(int,
MOCK_METHOD3(Recv, int(void*, size_t, int64_t*)); SendTo,
MOCK_METHOD4(RecvFrom, int(void*, size_t, SocketAddress*, int64_t*)); (const void*, size_t, const SocketAddress&),
MOCK_METHOD1(Listen, int(int)); (override));
MOCK_METHOD0(Close, int()); MOCK_METHOD(int, Recv, (void*, size_t, int64_t*), (override));
MOCK_CONST_METHOD0(GetError, int()); MOCK_METHOD(int,
MOCK_METHOD1(SetError, void(int)); RecvFrom,
MOCK_CONST_METHOD0(GetState, ConnState()); (void*, size_t, SocketAddress*, int64_t*),
MOCK_METHOD2(GetOption, int(Option, int*)); (override));
MOCK_METHOD2(SetOption, int(Option, int)); MOCK_METHOD(int, Listen, (int), (override));
MOCK_METHOD(int, Close, (), (override));
MOCK_METHOD(int, GetError, (), (const, override));
MOCK_METHOD(void, SetError, (int), (override));
MOCK_METHOD(ConnState, GetState, (), (const, override));
MOCK_METHOD(int, GetOption, (Option, int*), (override));
MOCK_METHOD(int, SetOption, (Option, int), (override));
}; };
class MockCertVerifier : public SSLCertificateVerifier { class MockCertVerifier : public SSLCertificateVerifier {
public: public:
virtual ~MockCertVerifier() = default; virtual ~MockCertVerifier() = default;
MOCK_METHOD1(Verify, bool(const SSLCertificate&)); MOCK_METHOD(bool, Verify, (const SSLCertificate&), (override));
}; };
} // namespace } // namespace

2
rtc_base/ssl_adapter_unittest.cc
View file

@ -50,7 +50,7 @@ static std::string GetSSLProtocolName(const rtc::SSLMode& ssl_mode) {
class MockCertVerifier : public rtc::SSLCertificateVerifier { class MockCertVerifier : public rtc::SSLCertificateVerifier {
public: public:
virtual ~MockCertVerifier() = default; virtual ~MockCertVerifier() = default;
MOCK_METHOD1(Verify, bool(const rtc::SSLCertificate&)); MOCK_METHOD(bool, Verify, (const rtc::SSLCertificate&), (override));
}; };
// TODO(benwright) - Move to using INSTANTIATE_TEST_SUITE_P instead of using // TODO(benwright) - Move to using INSTANTIATE_TEST_SUITE_P instead of using

2
rtc_base/synchronization/yield_policy_unittest.cc
View file

@ -20,7 +20,7 @@ namespace rtc {
namespace { namespace {
class MockYieldHandler : public YieldInterface { class MockYieldHandler : public YieldInterface {
public: public:
MOCK_METHOD0(YieldExecution, void()); MOCK_METHOD(void, YieldExecution, (), (override));
}; };
} // namespace } // namespace
TEST(YieldPolicyTest, HandlerReceivesYieldSignalWhenSet) { TEST(YieldPolicyTest, HandlerReceivesYieldSignalWhenSet) {

4
rtc_base/task_utils/repeating_task_unittest.cc
View file

@ -40,8 +40,8 @@ void Sleep(TimeDelta time_delta) {
class MockClosure { class MockClosure {
public: public:
MOCK_METHOD0(Call, TimeDelta()); MOCK_METHOD(TimeDelta, Call, ());
MOCK_METHOD0(Delete, void()); MOCK_METHOD(void, Delete, ());
}; };
class MoveOnlyClosure { class MoveOnlyClosure {