2012-02-02 08:37:48 +00:00
|
|
|
/*
|
|
|
|
|
* Copyright (c) 2012 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.
|
|
|
|
|
*/
|
|
|
|
|
|
2017-09-15 06:47:31 +02:00
|
|
|
#ifndef MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_
|
|
|
|
|
#define MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_
|
2012-06-07 08:10:14 +00:00
|
|
|
|
2015-12-10 05:05:27 -08:00
|
|
|
#include <set>
|
2018-03-22 15:17:27 -07:00
|
|
|
#include <string>
|
2015-12-10 05:05:27 -08:00
|
|
|
#include <utility>
|
|
|
|
|
#include <vector>
|
|
|
|
|
|
2018-06-14 12:59:38 +02:00
|
|
|
#include "absl/types/optional.h"
|
2018-05-17 12:35:56 +02:00
|
|
|
#include "api/video/video_bitrate_allocation.h"
|
2017-09-15 06:47:31 +02:00
|
|
|
#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 "rtc_base/checks.h"
|
|
|
|
|
#include "test/gmock.h"
|
2011-12-22 10:26:13 +00:00
|
|
|
|
|
|
|
|
namespace webrtc {
|
|
|
|
|
|
2014-07-31 14:59:24 +00:00
|
|
|
class MockRtpData : public RtpData {
|
|
|
|
|
public:
|
2018-03-09 15:37:03 +00:00
|
|
|
MockRtpData();
|
|
|
|
|
~MockRtpData();
|
|
|
|
|
|
2014-07-31 14:59:24 +00:00
|
|
|
MOCK_METHOD3(OnReceivedPayloadData,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(const uint8_t* payload_data,
|
|
|
|
|
size_t payload_size,
|
|
|
|
|
const WebRtcRTPHeader* rtp_header));
|
2014-07-31 14:59:24 +00:00
|
|
|
};
|
|
|
|
|
|
2011-12-22 10:26:13 +00:00
|
|
|
class MockRtpRtcp : public RtpRtcp {
|
|
|
|
|
public:
|
2018-03-09 15:37:03 +00:00
|
|
|
MockRtpRtcp();
|
|
|
|
|
~MockRtpRtcp();
|
|
|
|
|
|
2013-05-29 12:12:51 +00:00
|
|
|
MOCK_METHOD2(IncomingRtcpPacket,
|
2017-09-13 07:53:37 -07:00
|
|
|
void(const uint8_t* incoming_packet, size_t packet_length));
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_METHOD1(SetRemoteSSRC, void(uint32_t ssrc));
|
2017-01-10 08:58:32 -08:00
|
|
|
MOCK_METHOD1(SetMaxRtpPacketSize, void(size_t size));
|
|
|
|
|
MOCK_CONST_METHOD0(MaxRtpPacketSize, size_t());
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_METHOD1(RegisterSendPayload, int32_t(const CodecInst& voice_codec));
|
2016-02-26 16:31:37 +01:00
|
|
|
MOCK_METHOD2(RegisterVideoSendPayload,
|
|
|
|
|
void(int payload_type, const char* payload_name));
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_METHOD1(DeRegisterSendPayload, int32_t(int8_t payload_type));
|
2011-12-22 10:26:13 +00:00
|
|
|
MOCK_METHOD2(RegisterSendRtpHeaderExtension,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(RTPExtensionType type, uint8_t id));
|
2011-12-22 10:26:13 +00:00
|
|
|
MOCK_METHOD1(DeregisterSendRtpHeaderExtension,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(RTPExtensionType type));
|
2017-02-03 08:13:57 -08:00
|
|
|
MOCK_CONST_METHOD0(HasBweExtensions, bool());
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_CONST_METHOD0(StartTimestamp, uint32_t());
|
|
|
|
|
MOCK_METHOD1(SetStartTimestamp, void(uint32_t timestamp));
|
2016-04-15 14:59:13 +02:00
|
|
|
MOCK_CONST_METHOD0(SequenceNumber, uint16_t());
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_METHOD1(SetSequenceNumber, void(uint16_t seq));
|
2016-04-15 14:59:13 +02:00
|
|
|
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());
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_CONST_METHOD0(SSRC, uint32_t());
|
|
|
|
|
MOCK_METHOD1(SetSSRC, void(uint32_t ssrc));
|
2018-03-22 15:17:27 -07:00
|
|
|
MOCK_METHOD1(SetMid, void(const std::string& mid));
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_CONST_METHOD1(CSRCs, int32_t(uint32_t csrcs[kRtpCsrcSize]));
|
2014-11-24 08:25:50 +00:00
|
|
|
MOCK_METHOD1(SetCsrcs, void(const std::vector<uint32_t>& csrcs));
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_METHOD1(SetCSRCStatus, int32_t(bool include));
|
2015-01-13 14:15:15 +00:00
|
|
|
MOCK_METHOD1(SetRtxSendStatus, void(int modes));
|
|
|
|
|
MOCK_CONST_METHOD0(RtxSendStatus, int());
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_METHOD1(SetRtxSsrc, void(uint32_t));
|
2015-04-21 20:24:50 +08:00
|
|
|
MOCK_METHOD2(SetRtxSendPayloadType, void(int, int));
|
2018-06-14 12:59:38 +02:00
|
|
|
MOCK_CONST_METHOD0(FlexfecSsrc, absl::optional<uint32_t>());
|
2015-04-21 20:24:50 +08:00
|
|
|
MOCK_CONST_METHOD0(RtxSendPayloadType, std::pair<int, int>());
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_METHOD1(SetSendingStatus, int32_t(bool sending));
|
|
|
|
|
MOCK_CONST_METHOD0(Sending, bool());
|
|
|
|
|
MOCK_METHOD1(SetSendingMediaStatus, void(bool sending));
|
|
|
|
|
MOCK_CONST_METHOD0(SendingMedia, bool());
|
2011-12-22 10:26:13 +00:00
|
|
|
MOCK_CONST_METHOD4(BitrateSent,
|
2016-07-28 15:19:10 -07:00
|
|
|
void(uint32_t* total_rate,
|
|
|
|
|
uint32_t* video_rate,
|
|
|
|
|
uint32_t* fec_rate,
|
|
|
|
|
uint32_t* nack_rate));
|
2012-02-16 14:45:37 +00:00
|
|
|
MOCK_CONST_METHOD1(EstimatedReceiveBandwidth,
|
2016-07-28 15:19:10 -07:00
|
|
|
int(uint32_t* available_bandwidth));
|
2016-08-02 17:46:41 -07:00
|
|
|
MOCK_METHOD9(SendOutgoingData,
|
|
|
|
|
bool(FrameType frame_type,
|
|
|
|
|
int8_t payload_type,
|
|
|
|
|
uint32_t timestamp,
|
|
|
|
|
int64_t capture_time_ms,
|
|
|
|
|
const uint8_t* payload_data,
|
|
|
|
|
size_t payload_size,
|
|
|
|
|
const RTPFragmentationHeader* fragmentation,
|
|
|
|
|
const RTPVideoHeader* rtp_video_header,
|
|
|
|
|
uint32_t* frame_id_out));
|
2016-06-01 06:31:17 -07:00
|
|
|
MOCK_METHOD5(TimeToSendPacket,
|
|
|
|
|
bool(uint32_t ssrc,
|
|
|
|
|
uint16_t sequence_number,
|
|
|
|
|
int64_t capture_time_ms,
|
|
|
|
|
bool retransmission,
|
2017-02-17 03:59:43 -08:00
|
|
|
const PacedPacketInfo& pacing_info));
|
|
|
|
|
MOCK_METHOD2(TimeToSendPadding,
|
|
|
|
|
size_t(size_t bytes, const PacedPacketInfo& pacing_info));
|
2014-11-14 11:52:04 +00:00
|
|
|
MOCK_METHOD2(RegisterRtcpObservers,
|
2016-07-28 15:19:10 -07:00
|
|
|
void(RtcpIntraFrameObserver* intra_frame_callback,
|
|
|
|
|
RtcpBandwidthObserver* bandwidth_callback));
|
2015-10-02 02:36:56 -07:00
|
|
|
MOCK_CONST_METHOD0(RTCP, RtcpMode());
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_METHOD1(SetRTCPStatus, void(RtcpMode method));
|
|
|
|
|
MOCK_METHOD1(SetCNAME, int32_t(const char cname[RTCP_CNAME_SIZE]));
|
2011-12-22 10:26:13 +00:00
|
|
|
MOCK_CONST_METHOD2(RemoteCNAME,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(uint32_t remote_ssrc,
|
|
|
|
|
char cname[RTCP_CNAME_SIZE]));
|
2012-09-11 07:00:42 +00:00
|
|
|
MOCK_CONST_METHOD5(RemoteNTP,
|
2016-07-28 15:19:10 -07:00
|
|
|
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));
|
2011-12-22 10:26:13 +00:00
|
|
|
MOCK_METHOD2(AddMixedCNAME,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(uint32_t ssrc, const char cname[RTCP_CNAME_SIZE]));
|
|
|
|
|
MOCK_METHOD1(RemoveMixedCNAME, int32_t(uint32_t ssrc));
|
2011-12-22 10:26:13 +00:00
|
|
|
MOCK_CONST_METHOD5(RTT,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(uint32_t remote_ssrc,
|
|
|
|
|
int64_t* rtt,
|
|
|
|
|
int64_t* avg_rtt,
|
|
|
|
|
int64_t* min_rtt,
|
|
|
|
|
int64_t* max_rtt));
|
|
|
|
|
MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packet_type));
|
2015-05-11 10:17:43 +02:00
|
|
|
MOCK_METHOD1(SendCompoundRTCP,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(const std::set<RTCPPacketType>& packet_types));
|
2013-08-15 23:38:54 +00:00
|
|
|
MOCK_CONST_METHOD2(DataCountersRTP,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(size_t* bytes_sent, uint32_t* packets_sent));
|
2014-12-09 09:47:53 +00:00
|
|
|
MOCK_CONST_METHOD2(GetSendStreamDataCounters,
|
2016-07-28 15:19:10 -07:00
|
|
|
void(StreamDataCounters*, StreamDataCounters*));
|
2015-07-10 18:10:05 -07:00
|
|
|
MOCK_CONST_METHOD3(GetRtpPacketLossStats,
|
2016-07-28 15:19:10 -07:00
|
|
|
void(bool, uint32_t, struct RtpPacketLossStats*));
|
2012-01-11 13:00:08 +00:00
|
|
|
MOCK_CONST_METHOD1(RemoteRTCPStat,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(std::vector<RTCPReportBlock>* receive_blocks));
|
2011-12-22 10:26:13 +00:00
|
|
|
MOCK_METHOD4(SetRTCPApplicationSpecificData,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(uint8_t sub_type,
|
|
|
|
|
uint32_t name,
|
2015-12-15 02:54:47 -08:00
|
|
|
const uint8_t* data,
|
2016-07-28 15:19:10 -07:00
|
|
|
uint16_t length));
|
|
|
|
|
MOCK_METHOD1(SetRTCPVoIPMetrics, int32_t(const RTCPVoIPMetric* voip_metric));
|
|
|
|
|
MOCK_METHOD1(SetRtcpXrRrtrStatus, void(bool enable));
|
|
|
|
|
MOCK_CONST_METHOD0(RtcpXrRrtrStatus, bool());
|
2017-12-13 13:35:10 +01:00
|
|
|
MOCK_METHOD2(SetRemb, void(int64_t bitrate, std::vector<uint32_t> ssrcs));
|
2017-10-10 17:46:26 +02:00
|
|
|
MOCK_METHOD0(UnsetRemb, void());
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_CONST_METHOD0(TMMBR, bool());
|
|
|
|
|
MOCK_METHOD1(SetTMMBRStatus, void(bool enable));
|
|
|
|
|
MOCK_METHOD1(OnBandwidthEstimateUpdate, void(uint16_t bandwidth_kbit));
|
|
|
|
|
MOCK_CONST_METHOD0(SelectiveRetransmissions, int());
|
|
|
|
|
MOCK_METHOD1(SetSelectiveRetransmissions, int(uint8_t settings));
|
|
|
|
|
MOCK_METHOD2(SendNACK, int32_t(const uint16_t* nack_list, uint16_t size));
|
2016-03-12 03:30:23 -08:00
|
|
|
MOCK_METHOD1(SendNack, void(const std::vector<uint16_t>& sequence_numbers));
|
2011-12-22 10:26:13 +00:00
|
|
|
MOCK_METHOD2(SetStorePacketsStatus,
|
2016-07-28 15:19:10 -07:00
|
|
|
void(bool enable, uint16_t number_to_store));
|
2013-08-15 23:38:54 +00:00
|
|
|
MOCK_CONST_METHOD0(StorePackets, bool());
|
2014-12-18 13:50:16 +00:00
|
|
|
MOCK_METHOD1(RegisterRtcpStatisticsCallback, void(RtcpStatisticsCallback*));
|
|
|
|
|
MOCK_METHOD0(GetRtcpStatisticsCallback, RtcpStatisticsCallback*());
|
2015-09-08 13:25:16 -07:00
|
|
|
MOCK_METHOD1(SendFeedbackPacket, bool(const rtcp::TransportFeedback& packet));
|
2011-12-22 10:26:13 +00:00
|
|
|
MOCK_METHOD3(SendTelephoneEventOutband,
|
2016-07-28 15:19:10 -07:00
|
|
|
int32_t(uint8_t key, uint16_t time_ms, uint8_t level));
|
|
|
|
|
MOCK_METHOD1(SetAudioLevel, int32_t(uint8_t level_dbov));
|
|
|
|
|
MOCK_METHOD1(SetTargetSendBitrate, void(uint32_t bitrate_bps));
|
2016-11-07 03:05:06 -08:00
|
|
|
MOCK_METHOD2(SetUlpfecConfig,
|
|
|
|
|
void(int red_payload_type, int fec_payload_type));
|
2012-03-20 22:10:56 +00:00
|
|
|
MOCK_METHOD2(SetFecParameters,
|
2016-11-07 03:36:05 -08:00
|
|
|
bool(const FecProtectionParams& delta_params,
|
|
|
|
|
const FecProtectionParams& key_params));
|
2016-07-28 15:19:10 -07:00
|
|
|
MOCK_METHOD1(SetKeyFrameRequestMethod, int32_t(KeyFrameRequestMethod method));
|
|
|
|
|
MOCK_METHOD0(RequestKeyFrame, int32_t());
|
|
|
|
|
MOCK_METHOD0(Process, void());
|
2013-12-05 14:29:02 +00:00
|
|
|
MOCK_METHOD1(RegisterSendChannelRtpStatisticsCallback,
|
2016-07-28 15:19:10 -07:00
|
|
|
void(StreamDataCountersCallback*));
|
2013-12-05 14:29:02 +00:00
|
|
|
MOCK_CONST_METHOD0(GetSendChannelRtpStatisticsCallback,
|
2016-07-28 15:19:10 -07:00
|
|
|
StreamDataCountersCallback*(void));
|
2018-04-23 12:32:22 +02:00
|
|
|
MOCK_METHOD1(SetVideoBitrateAllocation, void(const VideoBitrateAllocation&));
|
2011-12-22 10:26:13 +00:00
|
|
|
// Members.
|
|
|
|
|
unsigned int remote_ssrc_;
|
2017-03-17 04:01:30 -07:00
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
// Mocking this method is currently not required and having a default
|
|
|
|
|
// implementation like MOCK_METHOD0(TimeUntilNextProcess, int64_t())
|
|
|
|
|
// can be dangerous since it can cause a tight loop on a process thread.
|
|
|
|
|
virtual int64_t TimeUntilNextProcess() { return 0xffffffff; }
|
2011-12-22 10:26:13 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
} // namespace webrtc
|
2012-06-07 08:10:14 +00:00
|
|
|
|
2017-09-15 06:47:31 +02:00
|
|
|
#endif // MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_
|