admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleanup rtp_rtcp mocks

Browse Source 
Modernise function to unified MOCK_METHOD macro, delete few deprecated functions on the way.
Remove default constructors to stress they do nothing special

Bug: None
Change-Id: Ie126f38f0589acb65886f25f754ca575c17af29b
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/174583
Reviewed-by: Erik Språng <sprang@webrtc.org>
Commit-Queue: Danil Chapovalov <danilchap@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#31191}
This commit is contained in:
Danil Chapovalov 2020-05-07 20:43:21 +02:00 committed by Commit Bot
parent 804393b369
commit 2454d85bb6
9 changed files with 199 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
modules/rtp_rtcp/BUILD.gn
View File

@ -370,12 +370,6 @@ rtc_library("fec_test_helper") {
rtc_library("mock_rtp_rtcp") {
testonly = true
sources = [
"mocks/mock_recovered_packet_receiver.cc",
"mocks/mock_rtcp_bandwidth_observer.cc",
"mocks/mock_rtcp_rtt_stats.cc",
"mocks/mock_rtp_rtcp.cc",
]
public = [
"mocks/mock_recovered_packet_receiver.h",
"mocks/mock_rtcp_bandwidth_observer.h",

18
modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.cc
View File

@ -1,18 +0,0 @@
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h"
namespace webrtc {
MockRecoveredPacketReceiver::MockRecoveredPacketReceiver() = default;
MockRecoveredPacketReceiver::~MockRecoveredPacketReceiver() = default;
} // namespace webrtc

7
modules/rtp_rtcp/mocks/mock_recovered_packet_receiver.h
View File

@ -18,9 +18,10 @@ namespace webrtc {
class MockRecoveredPacketReceiver : public RecoveredPacketReceiver {
public:
MockRecoveredPacketReceiver();
~MockRecoveredPacketReceiver();
MOCK_METHOD2(OnRecoveredPacket, void(const uint8_t* packet, size_t length));
MOCK_METHOD(void,
OnRecoveredPacket,
(const uint8_t* packet, size_t length),
(override));
};
} // namespace webrtc

18
modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.cc
View File

@ -1,18 +0,0 @@
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h"
namespace webrtc {
MockRtcpBandwidthObserver::MockRtcpBandwidthObserver() = default;
MockRtcpBandwidthObserver::~MockRtcpBandwidthObserver() = default;
} // namespace webrtc

11
modules/rtp_rtcp/mocks/mock_rtcp_bandwidth_observer.h
View File

@ -18,12 +18,11 @@ namespace webrtc {
class MockRtcpBandwidthObserver : public RtcpBandwidthObserver {
public:
MockRtcpBandwidthObserver();
~MockRtcpBandwidthObserver();
MOCK_METHOD1(OnReceivedEstimatedBitrate, void(uint32_t));
MOCK_METHOD3(OnReceivedRtcpReceiverReport,
void(const ReportBlockList&, int64_t, int64_t));
MOCK_METHOD(void, OnReceivedEstimatedBitrate, (uint32_t), (override));
MOCK_METHOD(void,
OnReceivedRtcpReceiverReport,
(const ReportBlockList&, int64_t, int64_t),
(override));
};
} // namespace webrtc
#endif // MODULES_RTP_RTCP_MOCKS_MOCK_RTCP_BANDWIDTH_OBSERVER_H_

18
modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.cc
View File

@ -1,18 +0,0 @@
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/rtp_rtcp/mocks/mock_rtcp_rtt_stats.h"
namespace webrtc {
MockRtcpRttStats::MockRtcpRttStats() = default;
MockRtcpRttStats::~MockRtcpRttStats() = default;
} // namespace webrtc

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

@ -18,11 +18,8 @@ namespace webrtc {
class MockRtcpRttStats : public RtcpRttStats {
public:
MockRtcpRttStats();
~MockRtcpRttStats();
MOCK_METHOD1(OnRttUpdate, void(int64_t rtt));
MOCK_CONST_METHOD0(LastProcessedRtt, int64_t());
MOCK_METHOD(void, OnRttUpdate, (int64_t rtt), (override));
MOCK_METHOD(int64_t, LastProcessedRtt, (), (const override));
};
} // namespace webrtc
#endif // MODULES_RTP_RTCP_MOCKS_MOCK_RTCP_RTT_STATS_H_

18
modules/rtp_rtcp/mocks/mock_rtp_rtcp.cc
View File

@ -1,18 +0,0 @@
/*
* Copyright (c) 2018 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "modules/rtp_rtcp/mocks/mock_rtp_rtcp.h"
namespace webrtc {
MockRtpRtcp::MockRtpRtcp() = default;
MockRtpRtcp::~MockRtpRtcp() = default;
} // namespace webrtc

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

@ -22,159 +22,205 @@
#include "modules/include/module.h"
#include "modules/rtp_rtcp/include/rtp_rtcp.h"
#include "modules/rtp_rtcp/include/rtp_rtcp_defines.h"
#include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "modules/rtp_rtcp/source/rtp_packet_to_send.h"
#include "rtc_base/checks.h"
#include "test/gmock.h"
namespace webrtc {
class MockRtpRtcp : public RtpRtcp {
public:
MockRtpRtcp();
~MockRtpRtcp();
MOCK_METHOD2(IncomingRtcpPacket,
void(const uint8_t* incoming_packet, size_t packet_length));
MOCK_METHOD1(SetRemoteSSRC, void(uint32_t ssrc));
MOCK_METHOD1(SetMaxRtpPacketSize, void(size_t size));
MOCK_CONST_METHOD0(MaxRtpPacketSize, size_t());
MOCK_METHOD2(RegisterSendPayloadFrequency,
void(int payload_type, int frequency));
MOCK_METHOD1(DeRegisterSendPayload, int32_t(int8_t payload_type));
MOCK_METHOD1(SetExtmapAllowMixed, void(bool extmap_allow_mixed));
MOCK_METHOD2(RegisterSendRtpHeaderExtension,
int32_t(RTPExtensionType type, uint8_t id));
MOCK_METHOD2(RegisterRtpHeaderExtension, void(absl::string_view uri, int id));
MOCK_METHOD1(DeregisterSendRtpHeaderExtension,
int32_t(RTPExtensionType type));
MOCK_METHOD1(DeregisterSendRtpHeaderExtension, void(absl::string_view uri));
MOCK_CONST_METHOD0(SupportsPadding, bool());
MOCK_CONST_METHOD0(SupportsRtxPayloadPadding, bool());
MOCK_CONST_METHOD0(StartTimestamp, uint32_t());
MOCK_METHOD1(SetStartTimestamp, void(uint32_t timestamp));
MOCK_CONST_METHOD0(SequenceNumber, uint16_t());
MOCK_METHOD1(SetSequenceNumber, void(uint16_t seq));
MOCK_METHOD1(SetRtpState, void(const RtpState& rtp_state));
MOCK_METHOD1(SetRtxState, void(const RtpState& rtp_state));
MOCK_CONST_METHOD0(GetRtpState, RtpState());
MOCK_CONST_METHOD0(GetRtxState, RtpState());
MOCK_CONST_METHOD0(SSRC, uint32_t());
MOCK_METHOD1(SetSSRC, void(uint32_t ssrc));
MOCK_METHOD1(SetRid, void(const std::string& rid));
MOCK_METHOD1(SetMid, void(const std::string& mid));
MOCK_CONST_METHOD1(CSRCs, int32_t(uint32_t csrcs[kRtpCsrcSize]));
MOCK_METHOD1(SetCsrcs, void(const std::vector<uint32_t>& csrcs));
MOCK_METHOD1(SetCSRCStatus, int32_t(bool include));
MOCK_METHOD1(SetRtxSendStatus, void(int modes));
MOCK_CONST_METHOD0(RtxSendStatus, int());
MOCK_CONST_METHOD0(RtxSsrc, absl::optional<uint32_t>());
MOCK_METHOD1(SetRtxSsrc, void(uint32_t));
MOCK_METHOD2(SetRtxSendPayloadType, void(int, int));
MOCK_CONST_METHOD0(FlexfecSsrc, absl::optional<uint32_t>());
MOCK_CONST_METHOD0(RtxSendPayloadType, std::pair<int, int>());
MOCK_METHOD1(SetSendingStatus, int32_t(bool sending));
MOCK_CONST_METHOD0(Sending, bool());
MOCK_METHOD1(SetSendingMediaStatus, void(bool sending));
MOCK_CONST_METHOD0(SendingMedia, bool());
MOCK_CONST_METHOD0(IsAudioConfigured, bool());
MOCK_METHOD1(SetAsPartOfAllocation, void(bool));
MOCK_CONST_METHOD4(BitrateSent,
void(uint32_t* total_rate,
uint32_t* video_rate,
uint32_t* fec_rate,
uint32_t* nack_rate));
MOCK_CONST_METHOD1(EstimatedReceiveBandwidth,
int(uint32_t* available_bandwidth));
MOCK_METHOD4(OnSendingRtpFrame, bool(uint32_t, int64_t, int, bool));
MOCK_METHOD2(TrySendPacket,
bool(RtpPacketToSend* packet,
const PacedPacketInfo& pacing_info));
MOCK_METHOD1(OnPacketsAcknowledged, void(rtc::ArrayView<const uint16_t>));
MOCK_METHOD1(
GeneratePadding,
std::vector<std::unique_ptr<RtpPacketToSend>>(size_t target_size_bytes));
MOCK_CONST_METHOD1(GetSentRtpPacketInfos,
std::vector<RtpSequenceNumberMap::Info>(
rtc::ArrayView<const uint16_t> sequence_numbers));
MOCK_CONST_METHOD0(ExpectedPerPacketOverhead, size_t(void));
MOCK_METHOD2(RegisterRtcpObservers,
void(RtcpIntraFrameObserver* intra_frame_callback,
RtcpBandwidthObserver* bandwidth_callback));
MOCK_CONST_METHOD0(RTCP, RtcpMode());
MOCK_METHOD1(SetRTCPStatus, void(RtcpMode method));
MOCK_METHOD1(SetCNAME, int32_t(const char cname[RTCP_CNAME_SIZE]));
MOCK_CONST_METHOD2(RemoteCNAME,
int32_t(uint32_t remote_ssrc,
char cname[RTCP_CNAME_SIZE]));
MOCK_CONST_METHOD5(RemoteNTP,
int32_t(uint32_t* received_ntp_secs,
uint32_t* received_ntp_frac,
uint32_t* rtcp_arrival_time_secs,
uint32_t* rtcp_arrival_time_frac,
uint32_t* rtcp_timestamp));
MOCK_METHOD2(AddMixedCNAME,
int32_t(uint32_t ssrc, const char cname[RTCP_CNAME_SIZE]));
MOCK_METHOD1(RemoveMixedCNAME, int32_t(uint32_t ssrc));
MOCK_CONST_METHOD5(RTT,
int32_t(uint32_t remote_ssrc,
int64_t* rtt,
int64_t* avg_rtt,
int64_t* min_rtt,
int64_t* max_rtt));
MOCK_CONST_METHOD0(ExpectedRetransmissionTimeMs, int64_t());
MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packet_type));
MOCK_METHOD1(SendCompoundRTCP,
int32_t(const std::set<RTCPPacketType>& packet_types));
MOCK_CONST_METHOD2(DataCountersRTP,
int32_t(size_t* bytes_sent, uint32_t* packets_sent));
MOCK_CONST_METHOD2(GetSendStreamDataCounters,
void(StreamDataCounters*, StreamDataCounters*));
MOCK_CONST_METHOD1(RemoteRTCPStat,
int32_t(std::vector<RTCPReportBlock>* receive_blocks));
MOCK_CONST_METHOD0(GetLatestReportBlockData, std::vector<ReportBlockData>());
MOCK_METHOD4(SetRTCPApplicationSpecificData,
int32_t(uint8_t sub_type,
uint32_t name,
const uint8_t* data,
uint16_t length));
MOCK_METHOD1(SetRtcpXrRrtrStatus, void(bool enable));
MOCK_CONST_METHOD0(RtcpXrRrtrStatus, bool());
MOCK_METHOD2(SetRemb, void(int64_t bitrate, std::vector<uint32_t> ssrcs));
MOCK_METHOD0(UnsetRemb, void());
MOCK_CONST_METHOD0(TMMBR, bool());
MOCK_METHOD1(SetTMMBRStatus, void(bool enable));
MOCK_METHOD1(OnBandwidthEstimateUpdate, void(uint16_t bandwidth_kbit));
MOCK_METHOD2(SendNACK, int32_t(const uint16_t* nack_list, uint16_t size));
MOCK_METHOD1(SendNack, void(const std::vector<uint16_t>& sequence_numbers));
MOCK_METHOD2(SetStorePacketsStatus,
void(bool enable, uint16_t number_to_store));
MOCK_CONST_METHOD0(StorePackets, bool());
MOCK_METHOD1(SendFeedbackPacket, bool(const rtcp::TransportFeedback& packet));
MOCK_METHOD1(SendNetworkStateEstimatePacket,
bool(const rtcp::RemoteEstimate& packet));
MOCK_METHOD1(
SendCombinedRtcpPacket,
void(std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets));
MOCK_METHOD1(SetTargetSendBitrate, void(uint32_t bitrate_bps));
MOCK_METHOD4(SendLossNotification,
int32_t(uint16_t last_decoded_seq_num,
uint16_t last_received_seq_num,
bool decodability_flag,
bool buffering_allowed));
MOCK_METHOD0(Process, void());
MOCK_METHOD1(SetVideoBitrateAllocation, void(const VideoBitrateAllocation&));
MOCK_METHOD0(RtpSender, RTPSender*());
MOCK_CONST_METHOD0(RtpSender, const RTPSender*());
// Members.
unsigned int remote_ssrc_;
MOCK_METHOD(void,
IncomingRtcpPacket,
(const uint8_t* incoming_packet, size_t packet_length),
(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(void,
RegisterSendPayloadFrequency,
(int payload_type, int frequency),
(override));
MOCK_METHOD(int32_t,
DeRegisterSendPayload,
(int8_t payload_type),
(override));
MOCK_METHOD(void, SetExtmapAllowMixed, (bool extmap_allow_mixed), (override));
MOCK_METHOD(int32_t,
RegisterSendRtpHeaderExtension,
(RTPExtensionType type, uint8_t id),
(override));
MOCK_METHOD(void,
RegisterRtpHeaderExtension,
(absl::string_view uri, int id),
(override));
MOCK_METHOD(int32_t,
DeregisterSendRtpHeaderExtension,
(RTPExtensionType type),
(override));
MOCK_METHOD(void,
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(void, SetStartTimestamp, (uint32_t timestamp), (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(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(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(int32_t, SetSendingStatus, (bool sending), (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(void, SetAsPartOfAllocation, (bool), (override));
MOCK_METHOD(void,
BitrateSent,
(uint32_t * total_rate,
uint32_t* video_rate,
uint32_t* fec_rate,
uint32_t* nack_rate),
(const override));
MOCK_METHOD(int,
EstimatedReceiveBandwidth,
(uint32_t * available_bandwidth),
(const override));
MOCK_METHOD(bool,
OnSendingRtpFrame,
(uint32_t, int64_t, int, bool),
(override));
MOCK_METHOD(bool,
TrySendPacket,
(RtpPacketToSend * packet, const PacedPacketInfo& pacing_info),
(override));
MOCK_METHOD(void,
OnPacketsAcknowledged,
(rtc::ArrayView<const uint16_t>),
(override));
MOCK_METHOD(std::vector<std::unique_ptr<RtpPacketToSend>>,
GeneratePadding,
(size_t target_size_bytes),
(override));
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));
MOCK_METHOD(void, SetRTCPStatus, (RtcpMode method), (override));
MOCK_METHOD(int32_t,
SetCNAME,
(const char cname[RTCP_CNAME_SIZE]),
(override));
MOCK_METHOD(int32_t,
RemoteCNAME,
(uint32_t remote_ssrc, char cname[RTCP_CNAME_SIZE]),
(const override));
MOCK_METHOD(int32_t,
RemoteNTP,
(uint32_t * received_ntp_secs,
uint32_t* received_ntp_frac,
uint32_t* rtcp_arrival_time_secs,
uint32_t* rtcp_arrival_time_frac,
uint32_t* rtcp_timestamp),
(const override));
MOCK_METHOD(int32_t,
AddMixedCNAME,
(uint32_t ssrc, const char cname[RTCP_CNAME_SIZE]),
(override));
MOCK_METHOD(int32_t, RemoveMixedCNAME, (uint32_t ssrc), (override));
MOCK_METHOD(int32_t,
RTT,
(uint32_t remote_ssrc,
int64_t* rtt,
int64_t* avg_rtt,
int64_t* min_rtt,
int64_t* max_rtt),
(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));
MOCK_METHOD(void,
GetSendStreamDataCounters,
(StreamDataCounters*, StreamDataCounters*),
(const override));
MOCK_METHOD(int32_t,
RemoteRTCPStat,
(std::vector<RTCPReportBlock> * receive_blocks),
(const override));
MOCK_METHOD(std::vector<ReportBlockData>,
GetLatestReportBlockData,
(),
(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(void,
SetRemb,
(int64_t bitrate, std::vector<uint32_t> ssrcs),
(override));
MOCK_METHOD(void, UnsetRemb, (), (override));
MOCK_METHOD(bool, TMMBR, (), (const override));
MOCK_METHOD(void, SetTMMBRStatus, (bool enable), (override));
MOCK_METHOD(int32_t,
SendNACK,
(const uint16_t* nack_list, uint16_t size),
(override));
MOCK_METHOD(void,
SendNack,
(const std::vector<uint16_t>& sequence_numbers),
(override));
MOCK_METHOD(void,
SetStorePacketsStatus,
(bool enable, uint16_t number_to_store),
(override));
MOCK_METHOD(bool, StorePackets, (), (const override));
MOCK_METHOD(void,
SendCombinedRtcpPacket,
(std::vector<std::unique_ptr<rtcp::RtcpPacket>> rtcp_packets),
(override));
MOCK_METHOD(int32_t,
SendLossNotification,
(uint16_t last_decoded_seq_num,
uint16_t last_received_seq_num,
bool decodability_flag,
bool buffering_allowed),
(override));
MOCK_METHOD(void, Process, (), (override));
MOCK_METHOD(void,
SetVideoBitrateAllocation,
(const VideoBitrateAllocation&),
(override));
MOCK_METHOD(RTPSender*, RtpSender, (), (override));
MOCK_METHOD(const RTPSender*, RtpSender, (), (const override));
private:
// Mocking this method is currently not required and having a default
// implementation like MOCK_METHOD0(TimeUntilNextProcess, int64_t())
// implementation like
// MOCK_METHOD(int64_t, TimeUntilNextProcess, (), (override))
// can be dangerous since it can cause a tight loop on a process thread.
virtual int64_t TimeUntilNextProcess() { return 0xffffffff; }
int64_t TimeUntilNextProcess() override { return 0xffffffff; }
};
} // namespace webrtc