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

In modules/ replace mock macros with unified MOCK_METHOD macro

Browse Source 
Bug: webrtc:11564
Change-Id: I8a87389a795029feb818449ab1e5bbe69486db28
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/175908
Reviewed-by: Philip Eliasson <philipel@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31364}
This commit is contained in:
Danil Chapovalov
2020-05-26 19:18:17 +02:00
committed by Commit Bot
parent e309651f33
commit 014197b581
14 changed files with 118 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
modules/congestion_controller/goog_cc/acknowledged_bitrate_estimator_unittest.cc
View File

@ -35,10 +35,12 @@ constexpr size_t kPayloadSize = 10;
class MockBitrateEstimator : public BitrateEstimator {
public:
using BitrateEstimator::BitrateEstimator;
MOCK_METHOD3(Update,
void(Timestamp at_time, DataSize data_size, bool in_alr));
MOCK_CONST_METHOD0(bitrate, absl::optional<DataRate>());
MOCK_METHOD0(ExpectFastRateChange, void());
MOCK_METHOD(void,
Update,
(Timestamp at_time, DataSize data_size, bool in_alr),
(override));
MOCK_METHOD(absl::optional<DataRate>, bitrate, (), (const, override));
MOCK_METHOD(void, ExpectFastRateChange, (), (override));
};
struct AcknowledgedBitrateEstimatorTestStates {

6
modules/congestion_controller/pcc/bitrate_controller_unittest.cc
View File

@ -67,8 +67,10 @@ std::vector<PacketResult> CreatePacketResults(
class MockUtilityFunction : public PccUtilityFunctionInterface {
public:
MOCK_CONST_METHOD1(Compute,
double(const PccMonitorInterval& monitor_interval));
MOCK_METHOD(double,
Compute,
(const PccMonitorInterval& monitor_interval),
(const, override));
};
} // namespace

6
modules/congestion_controller/receive_side_congestion_controller_unittest.cc
View File

@ -37,8 +37,10 @@ uint32_t AbsSendTime(int64_t t, int64_t denom) {
class MockPacketRouter : public PacketRouter {
public:
MOCK_METHOD2(OnReceiveBitrateChanged,
void(const std::vector<uint32_t>& ssrcs, uint32_t bitrate));
MOCK_METHOD(void,
OnReceiveBitrateChanged,
(const std::vector<uint32_t>& ssrcs, uint32_t bitrate),
(override));
};
const uint32_t kInitialBitrateBps = 60000;

6
modules/congestion_controller/rtp/transport_feedback_adapter_unittest.cc
View File

@ -83,8 +83,10 @@ namespace test {
class MockStreamFeedbackObserver : public webrtc::StreamFeedbackObserver {
public:
MOCK_METHOD1(OnPacketFeedbackVector,
void(std::vector<StreamPacketInfo> packet_feedback_vector));
MOCK_METHOD(void,
OnPacketFeedbackVector,
(std::vector<StreamPacketInfo> packet_feedback_vector),
(override));
};
class TransportFeedbackAdapterTest : public ::testing::Test {

6
modules/congestion_controller/rtp/transport_feedback_demuxer_unittest.cc
View File

@ -21,8 +21,10 @@ static constexpr uint32_t kSsrc = 8492;
class MockStreamFeedbackObserver : public webrtc::StreamFeedbackObserver {
public:
MOCK_METHOD1(OnPacketFeedbackVector,
void(std::vector<StreamPacketInfo> packet_feedback_vector));
MOCK_METHOD(void,
OnPacketFeedbackVector,
(std::vector<StreamPacketInfo> packet_feedback_vector),
(override));
};
RtpPacketSendInfo CreatePacket(uint32_t ssrc,

15
modules/pacing/paced_sender_unittest.cc
View File

@ -39,12 +39,15 @@ constexpr size_t kDefaultPacketSize = 234;
// Mock callback implementing the raw api.
class MockCallback : public PacketRouter {
public:
MOCK_METHOD2(SendPacket,
void(std::unique_ptr<RtpPacketToSend> packet,
const PacedPacketInfo& cluster_info));
MOCK_METHOD1(
GeneratePadding,
std::vector<std::unique_ptr<RtpPacketToSend>>(DataSize target_size));
MOCK_METHOD(void,
SendPacket,
(std::unique_ptr<RtpPacketToSend> packet,
const PacedPacketInfo& cluster_info),
(override));
MOCK_METHOD(std::vector<std::unique_ptr<RtpPacketToSend>>,
GeneratePadding,
(DataSize target_size),
(override));
};
class ProcessModeTrials : public WebRtcKeyValueConfig {

30
modules/pacing/pacing_controller_unittest.cc
View File

@ -90,24 +90,28 @@ class MockPacingControllerCallback : public PacingController::PacketSender {
return ret;
}
MOCK_METHOD5(SendPacket,
void(uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_timestamp,
bool retransmission,
bool padding));
MOCK_METHOD1(SendPadding, size_t(size_t target_size));
MOCK_METHOD(void,
SendPacket,
(uint32_t ssrc,
uint16_t sequence_number,
int64_t capture_timestamp,
bool retransmission,
bool padding));
MOCK_METHOD(size_t, SendPadding, (size_t target_size));
};
// Mock callback implementing the raw api.
class MockPacketSender : public PacingController::PacketSender {
public:
MOCK_METHOD2(SendPacket,
void(std::unique_ptr<RtpPacketToSend> packet,
const PacedPacketInfo& cluster_info));
MOCK_METHOD1(
GeneratePadding,
std::vector<std::unique_ptr<RtpPacketToSend>>(DataSize target_size));
MOCK_METHOD(void,
SendPacket,
(std::unique_ptr<RtpPacketToSend> packet,
const PacedPacketInfo& cluster_info),
(override));
MOCK_METHOD(std::vector<std::unique_ptr<RtpPacketToSend>>,
GeneratePadding,
(DataSize target_size),
(override));
};
class PacingControllerPadding : public PacingController::PacketSender {

15
modules/pacing/task_queue_paced_sender_unittest.cc
View File

@ -38,12 +38,15 @@ constexpr size_t kDefaultPacketSize = 1234;
class MockPacketRouter : public PacketRouter {
public:
MOCK_METHOD2(SendPacket,
void(std::unique_ptr<RtpPacketToSend> packet,
const PacedPacketInfo& cluster_info));
MOCK_METHOD1(
GeneratePadding,
std::vector<std::unique_ptr<RtpPacketToSend>>(DataSize target_size));
MOCK_METHOD(void,
SendPacket,
(std::unique_ptr<RtpPacketToSend> packet,
const PacedPacketInfo& cluster_info),
(override));
MOCK_METHOD(std::vector<std::unique_ptr<RtpPacketToSend>>,
GeneratePadding,
(DataSize target_size),
(override));
};
} // namespace

7
modules/remote_bitrate_estimator/remote_estimator_proxy_unittest.cc
View File

@ -65,9 +65,10 @@ std::vector<int64_t> TimestampsMs(
class MockTransportFeedbackSender : public TransportFeedbackSenderInterface {
public:
MOCK_METHOD1(
SendCombinedRtcpPacket,
bool(std::vector<std::unique_ptr<rtcp::RtcpPacket>> feedback_packets));
MOCK_METHOD(bool,
SendCombinedRtcpPacket,
(std::vector<std::unique_ptr<rtcp::RtcpPacket>> feedback_packets),
(override));
};
class RemoteEstimatorProxyTest : public ::testing::Test {

2
modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h
View File

@ -19,7 +19,7 @@ namespace webrtc {
class MockRtcpRttStats : public RtcpRttStats {
public:
MOCK_METHOD(void, OnRttUpdate, (int64_t rtt), (override));
MOCK_METHOD(int64_t, LastProcessedRtt, (), (const override));
MOCK_METHOD(int64_t, LastProcessedRtt, (), (const, override));
};
} // namespace webrtc
#endif // MODULES_RTP_RTCP_MOCKS_MOCK_RTCP_RTT_STATS_H_

68
modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
View File

@ -35,7 +35,7 @@ class MockRtpRtcp : public RtpRtcp {
(override));
MOCK_METHOD(void, SetRemoteSSRC, (uint32_t ssrc), (override));
MOCK_METHOD(void, SetMaxRtpPacketSize, (size_t size), (override));
MOCK_METHOD(size_t, MaxRtpPacketSize, (), (const override));
MOCK_METHOD(size_t, MaxRtpPacketSize, (), (const, override));
MOCK_METHOD(void,
RegisterSendPayloadFrequency,
(int payload_type, int frequency),
@ -61,32 +61,30 @@ class MockRtpRtcp : public RtpRtcp {
DeregisterSendRtpHeaderExtension,
(absl::string_view uri),
(override));
MOCK_METHOD(bool, SupportsPadding, (), (const override));
MOCK_METHOD(bool, SupportsRtxPayloadPadding, (), (const override));
MOCK_METHOD(uint32_t, StartTimestamp, (), (const override));
MOCK_METHOD(bool, SupportsPadding, (), (const, override));
MOCK_METHOD(bool, SupportsRtxPayloadPadding, (), (const, override));
MOCK_METHOD(uint32_t, StartTimestamp, (), (const, override));
MOCK_METHOD(void, SetStartTimestamp, (uint32_t timestamp), (override));
MOCK_METHOD(uint16_t, SequenceNumber, (), (const override));
MOCK_METHOD(uint16_t, SequenceNumber, (), (const, override));
MOCK_METHOD(void, SetSequenceNumber, (uint16_t seq), (override));
MOCK_METHOD(void, SetRtpState, (const RtpState& rtp_state), (override));
MOCK_METHOD(void, SetRtxState, (const RtpState& rtp_state), (override));
MOCK_METHOD(RtpState, GetRtpState, (), (const override));
MOCK_METHOD(RtpState, GetRtxState, (), (const override));
MOCK_METHOD(uint32_t, SSRC, (), (const override));
MOCK_METHOD(RtpState, GetRtpState, (), (const, override));
MOCK_METHOD(RtpState, GetRtxState, (), (const, override));
MOCK_METHOD(uint32_t, SSRC, (), (const, override));
MOCK_METHOD(void, SetRid, (const std::string& rid), (override));
MOCK_METHOD(void, SetMid, (const std::string& mid), (override));
MOCK_METHOD(int32_t, CSRCs, (uint32_t csrcs[kRtpCsrcSize]), (const override));
MOCK_METHOD(void, SetCsrcs, (const std::vector<uint32_t>& csrcs), (override));
MOCK_METHOD(void, SetRtxSendStatus, (int modes), (override));
MOCK_METHOD(int, RtxSendStatus, (), (const override));
MOCK_METHOD(absl::optional<uint32_t>, RtxSsrc, (), (const override));
MOCK_METHOD(int, RtxSendStatus, (), (const, override));
MOCK_METHOD(absl::optional<uint32_t>, RtxSsrc, (), (const, override));
MOCK_METHOD(void, SetRtxSendPayloadType, (int, int), (override));
MOCK_METHOD(absl::optional<uint32_t>, FlexfecSsrc, (), (const override));
MOCK_METHOD((std::pair<int, int>), RtxSendPayloadType, (), (const override));
MOCK_METHOD(absl::optional<uint32_t>, FlexfecSsrc, (), (const, override));
MOCK_METHOD(int32_t, SetSendingStatus, (bool sending), (override));
MOCK_METHOD(bool, Sending, (), (const override));
MOCK_METHOD(bool, Sending, (), (const, override));
MOCK_METHOD(void, SetSendingMediaStatus, (bool sending), (override));
MOCK_METHOD(bool, SendingMedia, (), (const override));
MOCK_METHOD(bool, IsAudioConfigured, (), (const override));
MOCK_METHOD(bool, SendingMedia, (), (const, override));
MOCK_METHOD(bool, IsAudioConfigured, (), (const, override));
MOCK_METHOD(void, SetAsPartOfAllocation, (bool), (override));
MOCK_METHOD(void,
BitrateSent,
@ -94,12 +92,8 @@ class MockRtpRtcp : public RtpRtcp {
uint32_t* video_rate,
uint32_t* fec_rate,
uint32_t* nack_rate),
(const override));
MOCK_METHOD(RtpSendRates, GetSendRates, (), (const override));
MOCK_METHOD(int,
EstimatedReceiveBandwidth,
(uint32_t * available_bandwidth),
(const override));
(const, override));
MOCK_METHOD(RtpSendRates, GetSendRates, (), (const, override));
MOCK_METHOD(bool,
OnSendingRtpFrame,
(uint32_t, int64_t, int, bool),
@ -119,9 +113,9 @@ class MockRtpRtcp : public RtpRtcp {
MOCK_METHOD(std::vector<RtpSequenceNumberMap::Info>,
GetSentRtpPacketInfos,
(rtc::ArrayView<const uint16_t> sequence_numbers),
(const override));
MOCK_METHOD(size_t, ExpectedPerPacketOverhead, (), (const override));
MOCK_METHOD(RtcpMode, RTCP, (), (const override));
(const, override));
MOCK_METHOD(size_t, ExpectedPerPacketOverhead, (), (const, override));
MOCK_METHOD(RtcpMode, RTCP, (), (const, override));
MOCK_METHOD(void, SetRTCPStatus, (RtcpMode method), (override));
MOCK_METHOD(int32_t,
SetCNAME,
@ -130,7 +124,7 @@ class MockRtpRtcp : public RtpRtcp {
MOCK_METHOD(int32_t,
RemoteCNAME,
(uint32_t remote_ssrc, char cname[RTCP_CNAME_SIZE]),
(const override));
(const, override));
MOCK_METHOD(int32_t,
RemoteNTP,
(uint32_t * received_ntp_secs,
@ -138,7 +132,7 @@ class MockRtpRtcp : public RtpRtcp {
uint32_t* rtcp_arrival_time_secs,
uint32_t* rtcp_arrival_time_frac,
uint32_t* rtcp_timestamp),
(const override));
(const, override));
MOCK_METHOD(int32_t,
AddMixedCNAME,
(uint32_t ssrc, const char cname[RTCP_CNAME_SIZE]),
@ -151,38 +145,38 @@ class MockRtpRtcp : public RtpRtcp {
int64_t* avg_rtt,
int64_t* min_rtt,
int64_t* max_rtt),
(const override));
MOCK_METHOD(int64_t, ExpectedRetransmissionTimeMs, (), (const override));
(const, override));
MOCK_METHOD(int64_t, ExpectedRetransmissionTimeMs, (), (const, override));
MOCK_METHOD(int32_t, SendRTCP, (RTCPPacketType packet_type), (override));
MOCK_METHOD(int32_t,
DataCountersRTP,
(size_t * bytes_sent, uint32_t* packets_sent),
(const override));
(const, override));
MOCK_METHOD(void,
GetSendStreamDataCounters,
(StreamDataCounters*, StreamDataCounters*),
(const override));
(const, override));
MOCK_METHOD(int32_t,
RemoteRTCPStat,
(std::vector<RTCPReportBlock> * receive_blocks),
(const override));
(const, override));
MOCK_METHOD(std::vector<ReportBlockData>,
GetLatestReportBlockData,
(),
(const override));
(const, override));
MOCK_METHOD(
int32_t,
SetRTCPApplicationSpecificData,
(uint8_t sub_type, uint32_t name, const uint8_t* data, uint16_t length),
(override));
MOCK_METHOD(void, SetRtcpXrRrtrStatus, (bool enable), (override));
MOCK_METHOD(bool, RtcpXrRrtrStatus, (), (const override));
MOCK_METHOD(bool, RtcpXrRrtrStatus, (), (const, override));
MOCK_METHOD(void,
SetRemb,
(int64_t bitrate, std::vector<uint32_t> ssrcs),
(override));
MOCK_METHOD(void, UnsetRemb, (), (override));
MOCK_METHOD(bool, TMMBR, (), (const override));
MOCK_METHOD(bool, TMMBR, (), (const, override));
MOCK_METHOD(void, SetTMMBRStatus, (bool enable), (override));
MOCK_METHOD(int32_t,
SendNACK,
@ -196,7 +190,7 @@ class MockRtpRtcp : public RtpRtcp {
SetStorePacketsStatus,
(bool enable, uint16_t number_to_store),
(override));
MOCK_METHOD(bool, StorePackets, (), (const override));
MOCK_METHOD(bool, StorePackets, (), (const, override));
MOCK_METHOD(void,
SendCombinedRtcpPacket,
(std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets),
@ -214,7 +208,7 @@ class MockRtpRtcp : public RtpRtcp {
(const VideoBitrateAllocation&),
(override));
MOCK_METHOD(RTPSender*, RtpSender, (), (override));
MOCK_METHOD(const RTPSender*, RtpSender, (), (const override));
MOCK_METHOD(const RTPSender*, RtpSender, (), (const, override));
private:
// Mocking this method is currently not required and having a default

12
modules/rtp_rtcp/source/rtcp_transceiver_impl_unittest.cc
View File

@ -55,15 +55,17 @@ using ::webrtc::test::RtcpPacketParser;
class MockReceiveStatisticsProvider : public webrtc::ReceiveStatisticsProvider {
public:
MOCK_METHOD1(RtcpReportBlocks, std::vector<ReportBlock>(size_t));
MOCK_METHOD(std::vector<ReportBlock>, RtcpReportBlocks, (size_t), (override));
};
class MockMediaReceiverRtcpObserver : public webrtc::MediaReceiverRtcpObserver {
public:
MOCK_METHOD3(OnSenderReport, void(uint32_t, NtpTime, uint32_t));
MOCK_METHOD1(OnBye, void(uint32_t));
MOCK_METHOD2(OnBitrateAllocation,
void(uint32_t, const VideoBitrateAllocation&));
MOCK_METHOD(void, OnSenderReport, (uint32_t, NtpTime, uint32_t), (override));
MOCK_METHOD(void, OnBye, (uint32_t), (override));
MOCK_METHOD(void,
OnBitrateAllocation,
(uint32_t, const VideoBitrateAllocation&),
(override));
};
// Since some tests will need to wait for this period, make it small to avoid

5
modules/rtp_rtcp/source/rtcp_transceiver_unittest.cc
View File

@ -42,7 +42,10 @@ using ::webrtc::test::RtcpPacketParser;
class MockMediaReceiverRtcpObserver : public webrtc::MediaReceiverRtcpObserver {
public:
MOCK_METHOD3(OnSenderReport, void(uint32_t, webrtc::NtpTime, uint32_t));
MOCK_METHOD(void,
OnSenderReport,
(uint32_t, webrtc::NtpTime, uint32_t),
(override));
};
constexpr int kTimeoutMs = 1000;

29
modules/rtp_rtcp/source/rtp_sender_unittest.cc
View File

@ -149,33 +149,32 @@ class MockRtpPacketPacer : public RtpPacketSender {
MockRtpPacketPacer() {}
virtual ~MockRtpPacketPacer() {}
MOCK_METHOD1(EnqueuePackets,
void(std::vector<std::unique_ptr<RtpPacketToSend>>));
MOCK_METHOD2(CreateProbeCluster, void(int bitrate_bps, int cluster_id));
MOCK_METHOD0(Pause, void());
MOCK_METHOD0(Resume, void());
MOCK_METHOD1(SetCongestionWindow,
void(absl::optional<int64_t> congestion_window_bytes));
MOCK_METHOD1(UpdateOutstandingData, void(int64_t outstanding_bytes));
MOCK_METHOD1(SetAccountForAudioPackets, void(bool account_for_audio));
MOCK_METHOD(void,
EnqueuePackets,
(std::vector<std::unique_ptr<RtpPacketToSend>>),
(override));
};
class MockSendSideDelayObserver : public SendSideDelayObserver {
public:
MOCK_METHOD4(SendSideDelayUpdated, void(int, int, uint64_t, uint32_t));
MOCK_METHOD(void,
SendSideDelayUpdated,
(int, int, uint64_t, uint32_t),
(override));
};
class MockSendPacketObserver : public SendPacketObserver {
public:
MOCK_METHOD3(OnSendPacket, void(uint16_t, int64_t, uint32_t));
MOCK_METHOD(void, OnSendPacket, (uint16_t, int64_t, uint32_t), (override));
};
class MockTransportFeedbackObserver : public TransportFeedbackObserver {
public:
MOCK_METHOD1(OnAddPacket, void(const RtpPacketSendInfo&));
MOCK_METHOD1(OnTransportFeedback, void(const rtcp::TransportFeedback&));
MOCK_METHOD(void, OnAddPacket, (const RtpPacketSendInfo&), (override));
MOCK_METHOD(void,
OnTransportFeedback,
(const rtcp::TransportFeedback&),
(override));
};
class StreamDataTestCallback : public StreamDataCountersCallback {