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

Browse source 
Bug: webrtc:11564
Change-Id: I81d06041b80ce470e4859c4d0ebad7ff0f831af9
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/175134
Reviewed-by: Björn Terelius <terelius@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31276}
This commit is contained in:
Danil Chapovalov 2020-05-14 22:06:18 +02:00 committed by Commit Bot
parent fa8019c3c3
commit 9a5efe925d
11 changed files with 161 additions and 97 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
call/adaptation/resource_unittest.cc
View file

@ -28,7 +28,8 @@ class MockResourceListener : public ResourceListener {
public:
MOCK_METHOD(void,
OnResourceUsageStateMeasured,
(rtc::scoped_refptr<Resource> resource));
(rtc::scoped_refptr<Resource> resource),
(override));
};
class ResourceTest : public ::testing::Test {

56
call/adaptation/test/fake_frame_rate_provider.h
View file

@ -21,29 +21,41 @@ namespace webrtc {
class MockVideoStreamEncoderObserver : public VideoStreamEncoderObserver {
public:
MOCK_METHOD2(OnEncodedFrameTimeMeasured, void(int, int));
MOCK_METHOD2(OnIncomingFrame, void(int, int));
MOCK_METHOD2(OnSendEncodedImage,
void(const EncodedImage&, const CodecSpecificInfo*));
MOCK_METHOD1(OnEncoderImplementationChanged, void(const std::string&));
MOCK_METHOD1(OnFrameDropped, void(DropReason));
MOCK_METHOD2(OnEncoderReconfigured,
void(const VideoEncoderConfig&,
const std::vector<VideoStream>&));
MOCK_METHOD3(OnAdaptationChanged,
void(VideoAdaptationReason,
MOCK_METHOD(void, OnEncodedFrameTimeMeasured, (int, int), (override));
MOCK_METHOD(void, OnIncomingFrame, (int, int), (override));
MOCK_METHOD(void,
OnSendEncodedImage,
(const EncodedImage&, const CodecSpecificInfo*),
(override));
MOCK_METHOD(void,
OnEncoderImplementationChanged,
(const std::string&),
(override));
MOCK_METHOD(void, OnFrameDropped, (DropReason), (override));
MOCK_METHOD(void,
OnEncoderReconfigured,
(const VideoEncoderConfig&, const std::vector<VideoStream>&),
(override));
MOCK_METHOD(void,
OnAdaptationChanged,
(VideoAdaptationReason,
const VideoAdaptationCounters&,
const VideoAdaptationCounters&));
MOCK_METHOD0(ClearAdaptationStats, void());
MOCK_METHOD2(UpdateAdaptationSettings,
void(AdaptationSettings, AdaptationSettings));
MOCK_METHOD0(OnMinPixelLimitReached, void());
MOCK_METHOD0(OnInitialQualityResolutionAdaptDown, void());
MOCK_METHOD1(OnSuspendChange, void(bool));
MOCK_METHOD2(OnBitrateAllocationUpdated,
void(const VideoCodec&, const VideoBitrateAllocation&));
MOCK_METHOD1(OnEncoderInternalScalerUpdate, void(bool));
MOCK_CONST_METHOD0(GetInputFrameRate, int());
const VideoAdaptationCounters&),
(override));
MOCK_METHOD(void, ClearAdaptationStats, (), (override));
MOCK_METHOD(void,
UpdateAdaptationSettings,
(AdaptationSettings, AdaptationSettings),
(override));
MOCK_METHOD(void, OnMinPixelLimitReached, (), (override));
MOCK_METHOD(void, OnInitialQualityResolutionAdaptDown, (), (override));
MOCK_METHOD(void, OnSuspendChange, (bool), (override));
MOCK_METHOD(void,
OnBitrateAllocationUpdated,
(const VideoCodec&, const VideoBitrateAllocation&),
(override));
MOCK_METHOD(void, OnEncoderInternalScalerUpdate, (bool), (override));
MOCK_METHOD(int, GetInputFrameRate, (), (const, override));
};
class FakeFrameRateProvider : public MockVideoStreamEncoderObserver {

5
call/bitrate_allocator_unittest.cc
View file

@ -47,7 +47,10 @@ auto AllocationLimitsEq(uint32_t min_allocatable_rate_bps,
class MockLimitObserver : public BitrateAllocator::LimitObserver {
public:
MOCK_METHOD1(OnAllocationLimitsChanged, void(BitrateAllocationLimits));
MOCK_METHOD(void,
OnAllocationLimitsChanged,
(BitrateAllocationLimits),
(override));
};
class TestBitrateObserver : public BitrateAllocatorObserver {

6
call/fake_network_pipe_unittest.cc
View file

@ -24,8 +24,10 @@ namespace webrtc {
class MockReceiver : public PacketReceiver {
public:
MOCK_METHOD3(DeliverPacket,
DeliveryStatus(MediaType, rtc::CopyOnWriteBuffer, int64_t));
MOCK_METHOD(DeliveryStatus,
DeliverPacket,
(MediaType, rtc::CopyOnWriteBuffer, int64_t),
(override));
virtual ~MockReceiver() = default;
};

2
call/rtcp_demuxer_unittest.cc
View file

@ -37,7 +37,7 @@ using ::testing::NiceMock;
class MockRtcpPacketSink : public RtcpPacketSinkInterface {
public:
MOCK_METHOD1(OnRtcpPacket, void(rtc::ArrayView<const uint8_t>));
MOCK_METHOD(void, OnRtcpPacket, (rtc::ArrayView<const uint8_t>), (override));
};
class RtcpDemuxerTest : public ::testing::Test {

24
call/rtp_demuxer_unittest.cc
View file

@ -37,14 +37,22 @@ using ::testing::NiceMock;
class MockSsrcBindingObserver : public SsrcBindingObserver {
public:
MOCK_METHOD2(OnSsrcBoundToRsid, void(const std::string& rsid, uint32_t ssrc));
MOCK_METHOD2(OnSsrcBoundToMid, void(const std::string& mid, uint32_t ssrc));
MOCK_METHOD3(OnSsrcBoundToMidRsid,
void(const std::string& mid,
const std::string& rsid,
uint32_t ssrc));
MOCK_METHOD2(OnSsrcBoundToPayloadType,
void(uint8_t payload_type, uint32_t ssrc));
MOCK_METHOD(void,
OnSsrcBoundToRsid,
(const std::string& rsid, uint32_t ssrc),
(override));
MOCK_METHOD(void,
OnSsrcBoundToMid,
(const std::string& mid, uint32_t ssrc),
(override));
MOCK_METHOD(void,
OnSsrcBoundToMidRsid,
(const std::string& mid, const std::string& rsid, uint32_t ssrc),
(override));
MOCK_METHOD(void,
OnSsrcBoundToPayloadType,
(uint8_t payload_type, uint32_t ssrc),
(override));
};
class RtpDemuxerTest : public ::testing::Test {

8
call/rtp_video_sender_unittest.cc
View file

@ -56,7 +56,7 @@ const int kDependencyDescriptorExtensionId = 8;
class MockRtcpIntraFrameObserver : public RtcpIntraFrameObserver {
public:
MOCK_METHOD1(OnReceivedIntraFrameRequest, void(uint32_t));
MOCK_METHOD(void, OnReceivedIntraFrameRequest, (uint32_t), (override));
};
RtpSenderObservers CreateObservers(
@ -361,8 +361,10 @@ TEST(RtpVideoSenderTest, CreateWithPreviousStates) {
TEST(RtpVideoSenderTest, FrameCountCallbacks) {
class MockFrameCountObserver : public FrameCountObserver {
public:
MOCK_METHOD2(FrameCountUpdated,
void(const FrameCounts& frame_counts, uint32_t ssrc));
MOCK_METHOD(void,
FrameCountUpdated,
(const FrameCounts& frame_counts, uint32_t ssrc),
(override));
} callback;
RtpVideoSenderTestFixture test({kSsrc1}, {kRtxSsrc1}, kPayloadType, {},

31
call/test/mock_audio_send_stream.h
View file

@ -21,23 +21,26 @@ namespace test {
class MockAudioSendStream : public AudioSendStream {
public:
MOCK_CONST_METHOD0(GetConfig, const webrtc::AudioSendStream::Config&());
MOCK_METHOD1(Reconfigure, void(const Config& config));
MOCK_METHOD0(Start, void());
MOCK_METHOD0(Stop, void());
MOCK_METHOD(const webrtc::AudioSendStream::Config&,
GetConfig,
(),
(const, override));
MOCK_METHOD(void, Reconfigure, (const Config& config), (override));
MOCK_METHOD(void, Start, (), (override));
MOCK_METHOD(void, Stop, (), (override));
// GMock doesn't like move-only types, such as std::unique_ptr.
virtual void SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame) {
void SendAudioData(std::unique_ptr<webrtc::AudioFrame> audio_frame) override {
SendAudioDataForMock(audio_frame.get());
}
MOCK_METHOD1(SendAudioDataForMock, void(webrtc::AudioFrame* audio_frame));
MOCK_METHOD4(SendTelephoneEvent,
bool(int payload_type,
int payload_frequency,
int event,
int duration_ms));
MOCK_METHOD1(SetMuted, void(bool muted));
MOCK_CONST_METHOD0(GetStats, Stats());
MOCK_CONST_METHOD1(GetStats, Stats(bool has_remote_tracks));
MOCK_METHOD(void, SendAudioDataForMock, (webrtc::AudioFrame*));
MOCK_METHOD(
bool,
SendTelephoneEvent,
(int payload_type, int payload_frequency, int event, int duration_ms),
(override));
MOCK_METHOD(void, SetMuted, (bool muted), (override));
MOCK_METHOD(Stats, GetStats, (), (const, override));
MOCK_METHOD(Stats, GetStats, (bool has_remote_tracks), (const, override));
};
} // namespace test
} // namespace webrtc

13
call/test/mock_bitrate_allocator.h
View file

@ -18,10 +18,15 @@
namespace webrtc {
class MockBitrateAllocator : public BitrateAllocatorInterface {
public:
MOCK_METHOD2(AddObserver,
void(BitrateAllocatorObserver*, MediaStreamAllocationConfig));
MOCK_METHOD1(RemoveObserver, void(BitrateAllocatorObserver*));
MOCK_CONST_METHOD1(GetStartBitrate, int(BitrateAllocatorObserver*));
MOCK_METHOD(void,
AddObserver,
(BitrateAllocatorObserver*, MediaStreamAllocationConfig),
(override));
MOCK_METHOD(void, RemoveObserver, (BitrateAllocatorObserver*), (override));
MOCK_METHOD(int,
GetStartBitrate,
(BitrateAllocatorObserver*),
(const, override));
};
} // namespace webrtc
#endif // CALL_TEST_MOCK_BITRATE_ALLOCATOR_H_

2
call/test/mock_rtp_packet_sink_interface.h
View file

@ -17,7 +17,7 @@ namespace webrtc {
class MockRtpPacketSink : public RtpPacketSinkInterface {
public:
MOCK_METHOD1(OnRtpPacket, void(const RtpPacketReceived&));
MOCK_METHOD(void, OnRtpPacket, (const RtpPacketReceived&), (override));
};
} // namespace webrtc

90
call/test/mock_rtp_transport_controller_send.h
View file

@ -32,10 +32,10 @@ namespace webrtc {
class MockRtpTransportControllerSend
: public RtpTransportControllerSendInterface {
public:
MOCK_METHOD10(
MOCK_METHOD(RtpVideoSenderInterface*,
CreateRtpVideoSender,
RtpVideoSenderInterface*(std::map<uint32_t, RtpState>,
const std::map<uint32_t, RtpPayloadState>&,
((std::map<uint32_t, RtpState>),
(const std::map<uint32_t, RtpPayloadState>&),
const RtpConfig&,
int rtcp_report_interval_ms,
Transport*,
@ -43,34 +43,62 @@ class MockRtpTransportControllerSend
RtcEventLog*,
std::unique_ptr<FecController>,
const RtpSenderFrameEncryptionConfig&,
rtc::scoped_refptr<FrameTransformerInterface>));
MOCK_METHOD1(DestroyRtpVideoSender, void(RtpVideoSenderInterface*));
MOCK_METHOD0(GetWorkerQueue, rtc::TaskQueue*());
MOCK_METHOD0(packet_router, PacketRouter*());
MOCK_METHOD0(network_state_estimate_observer,
NetworkStateEstimateObserver*());
MOCK_METHOD0(transport_feedback_observer, TransportFeedbackObserver*());
MOCK_METHOD0(packet_sender, RtpPacketSender*());
MOCK_METHOD1(SetAllocatedSendBitrateLimits, void(BitrateAllocationLimits));
MOCK_METHOD1(SetPacingFactor, void(float));
MOCK_METHOD1(SetQueueTimeLimit, void(int));
MOCK_METHOD0(GetStreamFeedbackProvider, StreamFeedbackProvider*());
MOCK_METHOD1(RegisterTargetTransferRateObserver,
void(TargetTransferRateObserver*));
MOCK_METHOD2(OnNetworkRouteChanged,
void(const std::string&, const rtc::NetworkRoute&));
MOCK_METHOD1(OnNetworkAvailability, void(bool));
MOCK_METHOD0(GetBandwidthObserver, RtcpBandwidthObserver*());
MOCK_CONST_METHOD0(GetPacerQueuingDelayMs, int64_t());
MOCK_CONST_METHOD0(GetFirstPacketTime, absl::optional<Timestamp>());
MOCK_METHOD1(EnablePeriodicAlrProbing, void(bool));
MOCK_METHOD1(OnSentPacket, void(const rtc::SentPacket&));
MOCK_METHOD1(SetSdpBitrateParameters, void(const BitrateConstraints&));
MOCK_METHOD1(SetClientBitratePreferences, void(const BitrateSettings&));
MOCK_METHOD1(OnTransportOverheadChanged, void(size_t));
MOCK_METHOD1(AccountForAudioPacketsInPacedSender, void(bool));
MOCK_METHOD0(IncludeOverheadInPacedSender, void());
MOCK_METHOD1(OnReceivedPacket, void(const ReceivedPacket&));
rtc::scoped_refptr<FrameTransformerInterface>),
(override));
MOCK_METHOD(void,
DestroyRtpVideoSender,
(RtpVideoSenderInterface*),
(override));
MOCK_METHOD(rtc::TaskQueue*, GetWorkerQueue, (), (override));
MOCK_METHOD(PacketRouter*, packet_router, (), (override));
MOCK_METHOD(NetworkStateEstimateObserver*,
network_state_estimate_observer,
(),
(override));
MOCK_METHOD(TransportFeedbackObserver*,
transport_feedback_observer,
(),
(override));
MOCK_METHOD(RtpPacketSender*, packet_sender, (), (override));
MOCK_METHOD(void,
SetAllocatedSendBitrateLimits,
(BitrateAllocationLimits),
(override));
MOCK_METHOD(void, SetPacingFactor, (float), (override));
MOCK_METHOD(void, SetQueueTimeLimit, (int), (override));
MOCK_METHOD(StreamFeedbackProvider*,
GetStreamFeedbackProvider,
(),
(override));
MOCK_METHOD(void,
RegisterTargetTransferRateObserver,
(TargetTransferRateObserver*),
(override));
MOCK_METHOD(void,
OnNetworkRouteChanged,
(const std::string&, const rtc::NetworkRoute&),
(override));
MOCK_METHOD(void, OnNetworkAvailability, (bool), (override));
MOCK_METHOD(RtcpBandwidthObserver*, GetBandwidthObserver, (), (override));
MOCK_METHOD(int64_t, GetPacerQueuingDelayMs, (), (const, override));
MOCK_METHOD(absl::optional<Timestamp>,
GetFirstPacketTime,
(),
(const, override));
MOCK_METHOD(void, EnablePeriodicAlrProbing, (bool), (override));
MOCK_METHOD(void, OnSentPacket, (const rtc::SentPacket&), (override));
MOCK_METHOD(void,
SetSdpBitrateParameters,
(const BitrateConstraints&),
(override));
MOCK_METHOD(void,
SetClientBitratePreferences,
(const BitrateSettings&),
(override));
MOCK_METHOD(void, OnTransportOverheadChanged, (size_t), (override));
MOCK_METHOD(void, AccountForAudioPacketsInPacedSender, (bool), (override));
MOCK_METHOD(void, IncludeOverheadInPacedSender, (), (override));
MOCK_METHOD(void, OnReceivedPacket, (const ReceivedPacket&), (override));
};
} // namespace webrtc
#endif // CALL_TEST_MOCK_RTP_TRANSPORT_CONTROLLER_SEND_H_