stefan@webrtc.org | 07b45a5 | 2012-02-02 08:37:48 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license |
| 5 | * that can be found in the LICENSE file in the root of the source |
| 6 | * tree. An additional intellectual property rights grant can be found |
| 7 | * in the file PATENTS. All contributing project authors may |
| 8 | * be found in the AUTHORS file in the root of the source tree. |
| 9 | */ |
| 10 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 11 | #ifndef MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_ |
| 12 | #define MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_ |
stefan@webrtc.org | 9354cc9 | 2012-06-07 08:10:14 +0000 | [diff] [blame] | 13 | |
Erik Språng | 9c771c2 | 2019-06-17 16:31:53 +0200 | [diff] [blame^] | 14 | #include <memory> |
danilchap | b8b6fbb | 2015-12-10 05:05:27 -0800 | [diff] [blame] | 15 | #include <set> |
Steve Anton | 296a0ce | 2018-03-22 15:17:27 -0700 | [diff] [blame] | 16 | #include <string> |
danilchap | b8b6fbb | 2015-12-10 05:05:27 -0800 | [diff] [blame] | 17 | #include <utility> |
| 18 | #include <vector> |
| 19 | |
Danil Chapovalov | d264df5 | 2018-06-14 12:59:38 +0200 | [diff] [blame] | 20 | #include "absl/types/optional.h" |
Erik Språng | eeaa8f9 | 2018-05-17 12:35:56 +0200 | [diff] [blame] | 21 | #include "api/video/video_bitrate_allocation.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 22 | #include "modules/include/module.h" |
| 23 | #include "modules/rtp_rtcp/include/rtp_rtcp.h" |
| 24 | #include "modules/rtp_rtcp/include/rtp_rtcp_defines.h" |
| 25 | #include "modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
Erik Språng | 9c771c2 | 2019-06-17 16:31:53 +0200 | [diff] [blame^] | 26 | #include "modules/rtp_rtcp/source/rtp_packet_to_send.h" |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 27 | #include "rtc_base/checks.h" |
| 28 | #include "test/gmock.h" |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 29 | |
| 30 | namespace webrtc { |
| 31 | |
| 32 | class MockRtpRtcp : public RtpRtcp { |
| 33 | public: |
Danil Chapovalov | dd7e284 | 2018-03-09 15:37:03 +0000 | [diff] [blame] | 34 | MockRtpRtcp(); |
| 35 | ~MockRtpRtcp(); |
| 36 | |
stefan@webrtc.org | a5cb98c | 2013-05-29 12:12:51 +0000 | [diff] [blame] | 37 | MOCK_METHOD2(IncomingRtcpPacket, |
nisse | 479d3d7 | 2017-09-13 07:53:37 -0700 | [diff] [blame] | 38 | void(const uint8_t* incoming_packet, size_t packet_length)); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 39 | MOCK_METHOD1(SetRemoteSSRC, void(uint32_t ssrc)); |
nisse | 284542b | 2017-01-10 08:58:32 -0800 | [diff] [blame] | 40 | MOCK_METHOD1(SetMaxRtpPacketSize, void(size_t size)); |
nisse | 284542b | 2017-01-10 08:58:32 -0800 | [diff] [blame] | 41 | MOCK_CONST_METHOD0(MaxRtpPacketSize, size_t()); |
Niels Möller | 5fe9510 | 2019-03-04 16:49:25 +0100 | [diff] [blame] | 42 | MOCK_METHOD2(RegisterSendPayloadFrequency, |
| 43 | void(int payload_type, int frequency)); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 44 | MOCK_METHOD1(DeRegisterSendPayload, int32_t(int8_t payload_type)); |
Johannes Kron | 9190b82 | 2018-10-29 11:22:05 +0100 | [diff] [blame] | 45 | MOCK_METHOD1(SetExtmapAllowMixed, void(bool extmap_allow_mixed)); |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 46 | MOCK_METHOD2(RegisterSendRtpHeaderExtension, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 47 | int32_t(RTPExtensionType type, uint8_t id)); |
Danil Chapovalov | 585d1aa | 2018-09-14 18:29:32 +0200 | [diff] [blame] | 48 | MOCK_METHOD2(RegisterRtpHeaderExtension, |
| 49 | bool(const std::string& uri, int id)); |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 50 | MOCK_METHOD1(DeregisterSendRtpHeaderExtension, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 51 | int32_t(RTPExtensionType type)); |
stefan | 53b6cc3 | 2017-02-03 08:13:57 -0800 | [diff] [blame] | 52 | MOCK_CONST_METHOD0(HasBweExtensions, bool()); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 53 | MOCK_CONST_METHOD0(StartTimestamp, uint32_t()); |
| 54 | MOCK_METHOD1(SetStartTimestamp, void(uint32_t timestamp)); |
Per | 83d0910 | 2016-04-15 14:59:13 +0200 | [diff] [blame] | 55 | MOCK_CONST_METHOD0(SequenceNumber, uint16_t()); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 56 | MOCK_METHOD1(SetSequenceNumber, void(uint16_t seq)); |
Per | 83d0910 | 2016-04-15 14:59:13 +0200 | [diff] [blame] | 57 | MOCK_METHOD1(SetRtpState, void(const RtpState& rtp_state)); |
| 58 | MOCK_METHOD1(SetRtxState, void(const RtpState& rtp_state)); |
| 59 | MOCK_CONST_METHOD0(GetRtpState, RtpState()); |
| 60 | MOCK_CONST_METHOD0(GetRtxState, RtpState()); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 61 | MOCK_CONST_METHOD0(SSRC, uint32_t()); |
| 62 | MOCK_METHOD1(SetSSRC, void(uint32_t ssrc)); |
Amit Hilbuch | 77938e6 | 2018-12-21 09:23:38 -0800 | [diff] [blame] | 63 | MOCK_METHOD1(SetRid, void(const std::string& rid)); |
Steve Anton | 296a0ce | 2018-03-22 15:17:27 -0700 | [diff] [blame] | 64 | MOCK_METHOD1(SetMid, void(const std::string& mid)); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 65 | MOCK_CONST_METHOD1(CSRCs, int32_t(uint32_t csrcs[kRtpCsrcSize])); |
pbos@webrtc.org | 9334ac2 | 2014-11-24 08:25:50 +0000 | [diff] [blame] | 66 | MOCK_METHOD1(SetCsrcs, void(const std::vector<uint32_t>& csrcs)); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 67 | MOCK_METHOD1(SetCSRCStatus, int32_t(bool include)); |
pbos@webrtc.org | 0b0c241 | 2015-01-13 14:15:15 +0000 | [diff] [blame] | 68 | MOCK_METHOD1(SetRtxSendStatus, void(int modes)); |
| 69 | MOCK_CONST_METHOD0(RtxSendStatus, int()); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 70 | MOCK_METHOD1(SetRtxSsrc, void(uint32_t)); |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 71 | MOCK_METHOD2(SetRtxSendPayloadType, void(int, int)); |
Danil Chapovalov | d264df5 | 2018-06-14 12:59:38 +0200 | [diff] [blame] | 72 | MOCK_CONST_METHOD0(FlexfecSsrc, absl::optional<uint32_t>()); |
Shao Changbin | e62202f | 2015-04-21 20:24:50 +0800 | [diff] [blame] | 73 | MOCK_CONST_METHOD0(RtxSendPayloadType, std::pair<int, int>()); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 74 | MOCK_METHOD1(SetSendingStatus, int32_t(bool sending)); |
| 75 | MOCK_CONST_METHOD0(Sending, bool()); |
| 76 | MOCK_METHOD1(SetSendingMediaStatus, void(bool sending)); |
| 77 | MOCK_CONST_METHOD0(SendingMedia, bool()); |
Sebastian Jansson | 1bca65b | 2018-10-10 09:58:08 +0200 | [diff] [blame] | 78 | MOCK_METHOD1(SetAsPartOfAllocation, void(bool)); |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 79 | MOCK_CONST_METHOD4(BitrateSent, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 80 | void(uint32_t* total_rate, |
| 81 | uint32_t* video_rate, |
| 82 | uint32_t* fec_rate, |
| 83 | uint32_t* nack_rate)); |
stefan@webrtc.org | 439be29 | 2012-02-16 14:45:37 +0000 | [diff] [blame] | 84 | MOCK_CONST_METHOD1(EstimatedReceiveBandwidth, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 85 | int(uint32_t* available_bandwidth)); |
Niels Möller | 5fe9510 | 2019-03-04 16:49:25 +0100 | [diff] [blame] | 86 | MOCK_METHOD4(OnSendingRtpFrame, bool(uint32_t, int64_t, int, bool)); |
philipel | a1ed0b3 | 2016-06-01 06:31:17 -0700 | [diff] [blame] | 87 | MOCK_METHOD5(TimeToSendPacket, |
Erik Språng | d287962 | 2019-05-10 08:29:01 -0700 | [diff] [blame] | 88 | RtpPacketSendResult(uint32_t ssrc, |
| 89 | uint16_t sequence_number, |
| 90 | int64_t capture_time_ms, |
| 91 | bool retransmission, |
| 92 | const PacedPacketInfo& pacing_info)); |
Erik Språng | 9c771c2 | 2019-06-17 16:31:53 +0200 | [diff] [blame^] | 93 | MOCK_METHOD2(TrySendPacket, |
| 94 | bool(RtpPacketToSend* packet, |
| 95 | const PacedPacketInfo& pacing_info)); |
philipel | c7bf32a | 2017-02-17 03:59:43 -0800 | [diff] [blame] | 96 | MOCK_METHOD2(TimeToSendPadding, |
| 97 | size_t(size_t bytes, const PacedPacketInfo& pacing_info)); |
pbos@webrtc.org | ece3890 | 2014-11-14 11:52:04 +0000 | [diff] [blame] | 98 | MOCK_METHOD2(RegisterRtcpObservers, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 99 | void(RtcpIntraFrameObserver* intra_frame_callback, |
| 100 | RtcpBandwidthObserver* bandwidth_callback)); |
pbos | da903ea | 2015-10-02 02:36:56 -0700 | [diff] [blame] | 101 | MOCK_CONST_METHOD0(RTCP, RtcpMode()); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 102 | MOCK_METHOD1(SetRTCPStatus, void(RtcpMode method)); |
| 103 | MOCK_METHOD1(SetCNAME, int32_t(const char cname[RTCP_CNAME_SIZE])); |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 104 | MOCK_CONST_METHOD2(RemoteCNAME, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 105 | int32_t(uint32_t remote_ssrc, |
| 106 | char cname[RTCP_CNAME_SIZE])); |
stefan@webrtc.org | 7c3523c | 2012-09-11 07:00:42 +0000 | [diff] [blame] | 107 | MOCK_CONST_METHOD5(RemoteNTP, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 108 | int32_t(uint32_t* received_ntp_secs, |
| 109 | uint32_t* received_ntp_frac, |
| 110 | uint32_t* rtcp_arrival_time_secs, |
| 111 | uint32_t* rtcp_arrival_time_frac, |
| 112 | uint32_t* rtcp_timestamp)); |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 113 | MOCK_METHOD2(AddMixedCNAME, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 114 | int32_t(uint32_t ssrc, const char cname[RTCP_CNAME_SIZE])); |
| 115 | MOCK_METHOD1(RemoveMixedCNAME, int32_t(uint32_t ssrc)); |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 116 | MOCK_CONST_METHOD5(RTT, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 117 | int32_t(uint32_t remote_ssrc, |
| 118 | int64_t* rtt, |
| 119 | int64_t* avg_rtt, |
| 120 | int64_t* min_rtt, |
| 121 | int64_t* max_rtt)); |
Niels Möller | 5fe9510 | 2019-03-04 16:49:25 +0100 | [diff] [blame] | 122 | MOCK_CONST_METHOD0(ExpectedRetransmissionTimeMs, int64_t()); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 123 | MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packet_type)); |
Erik Språng | 242e22b | 2015-05-11 10:17:43 +0200 | [diff] [blame] | 124 | MOCK_METHOD1(SendCompoundRTCP, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 125 | int32_t(const std::set<RTCPPacketType>& packet_types)); |
wu@webrtc.org | 822fbd8 | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 126 | MOCK_CONST_METHOD2(DataCountersRTP, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 127 | int32_t(size_t* bytes_sent, uint32_t* packets_sent)); |
asapersson@webrtc.org | 97d0489 | 2014-12-09 09:47:53 +0000 | [diff] [blame] | 128 | MOCK_CONST_METHOD2(GetSendStreamDataCounters, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 129 | void(StreamDataCounters*, StreamDataCounters*)); |
perkj@webrtc.org | ce5990c | 2012-01-11 13:00:08 +0000 | [diff] [blame] | 130 | MOCK_CONST_METHOD1(RemoteRTCPStat, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 131 | int32_t(std::vector<RTCPReportBlock>* receive_blocks)); |
Henrik Boström | 6e436d1 | 2019-05-27 12:19:33 +0200 | [diff] [blame] | 132 | MOCK_CONST_METHOD0(GetLatestReportBlockData, std::vector<ReportBlockData>()); |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 133 | MOCK_METHOD4(SetRTCPApplicationSpecificData, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 134 | int32_t(uint8_t sub_type, |
| 135 | uint32_t name, |
danilchap | 6db6cdc | 2015-12-15 02:54:47 -0800 | [diff] [blame] | 136 | const uint8_t* data, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 137 | uint16_t length)); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 138 | MOCK_METHOD1(SetRtcpXrRrtrStatus, void(bool enable)); |
| 139 | MOCK_CONST_METHOD0(RtcpXrRrtrStatus, bool()); |
Danil Chapovalov | 1de4b62 | 2017-12-13 13:35:10 +0100 | [diff] [blame] | 140 | MOCK_METHOD2(SetRemb, void(int64_t bitrate, std::vector<uint32_t> ssrcs)); |
Danil Chapovalov | 51e21aa | 2017-10-10 17:46:26 +0200 | [diff] [blame] | 141 | MOCK_METHOD0(UnsetRemb, void()); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 142 | MOCK_CONST_METHOD0(TMMBR, bool()); |
| 143 | MOCK_METHOD1(SetTMMBRStatus, void(bool enable)); |
| 144 | MOCK_METHOD1(OnBandwidthEstimateUpdate, void(uint16_t bandwidth_kbit)); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 145 | MOCK_METHOD2(SendNACK, int32_t(const uint16_t* nack_list, uint16_t size)); |
philipel | 83f831a | 2016-03-12 03:30:23 -0800 | [diff] [blame] | 146 | MOCK_METHOD1(SendNack, void(const std::vector<uint16_t>& sequence_numbers)); |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 147 | MOCK_METHOD2(SetStorePacketsStatus, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 148 | void(bool enable, uint16_t number_to_store)); |
wu@webrtc.org | 822fbd8 | 2013-08-15 23:38:54 +0000 | [diff] [blame] | 149 | MOCK_CONST_METHOD0(StorePackets, bool()); |
pbos@webrtc.org | ce4e9a3 | 2014-12-18 13:50:16 +0000 | [diff] [blame] | 150 | MOCK_METHOD1(RegisterRtcpStatisticsCallback, void(RtcpStatisticsCallback*)); |
| 151 | MOCK_METHOD0(GetRtcpStatisticsCallback, RtcpStatisticsCallback*()); |
Henrik Boström | 87e3f9d | 2019-05-27 10:44:24 +0200 | [diff] [blame] | 152 | MOCK_METHOD1(SetReportBlockDataObserver, void(ReportBlockDataObserver*)); |
sprang | 233bd87 | 2015-09-08 13:25:16 -0700 | [diff] [blame] | 153 | MOCK_METHOD1(SendFeedbackPacket, bool(const rtcp::TransportFeedback& packet)); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 154 | MOCK_METHOD1(SetTargetSendBitrate, void(uint32_t bitrate_bps)); |
Elad Alon | e86af2c | 2019-06-03 14:37:50 +0200 | [diff] [blame] | 155 | MOCK_METHOD4(SendLossNotification, |
Elad Alon | 7d6a4c0 | 2019-02-25 13:00:51 +0100 | [diff] [blame] | 156 | int32_t(uint16_t last_decoded_seq_num, |
| 157 | uint16_t last_received_seq_num, |
Elad Alon | e86af2c | 2019-06-03 14:37:50 +0200 | [diff] [blame] | 158 | bool decodability_flag, |
| 159 | bool buffering_allowed)); |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 160 | MOCK_METHOD0(Process, void()); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 161 | MOCK_METHOD1(RegisterSendChannelRtpStatisticsCallback, |
Sergey Ulanov | ec4f068 | 2016-07-28 15:19:10 -0700 | [diff] [blame] | 162 | void(StreamDataCountersCallback*)); |
sprang@webrtc.org | ebad765 | 2013-12-05 14:29:02 +0000 | [diff] [blame] | 163 | MOCK_CONST_METHOD0(GetSendChannelRtpStatisticsCallback, |
Erik Språng | 490d76c | 2019-05-07 09:29:15 -0700 | [diff] [blame] | 164 | StreamDataCountersCallback*()); |
Erik Språng | 566124a | 2018-04-23 12:32:22 +0200 | [diff] [blame] | 165 | MOCK_METHOD1(SetVideoBitrateAllocation, void(const VideoBitrateAllocation&)); |
Niels Möller | 5fe9510 | 2019-03-04 16:49:25 +0100 | [diff] [blame] | 166 | MOCK_METHOD0(RtpSender, RTPSender*()); |
| 167 | MOCK_CONST_METHOD0(RtpSender, const RTPSender*()); |
| 168 | |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 169 | // Members. |
| 170 | unsigned int remote_ssrc_; |
tommi | 994ebb4 | 2017-03-17 04:01:30 -0700 | [diff] [blame] | 171 | |
| 172 | private: |
| 173 | // Mocking this method is currently not required and having a default |
| 174 | // implementation like MOCK_METHOD0(TimeUntilNextProcess, int64_t()) |
| 175 | // can be dangerous since it can cause a tight loop on a process thread. |
| 176 | virtual int64_t TimeUntilNextProcess() { return 0xffffffff; } |
mflodman@webrtc.org | 84dc3d1 | 2011-12-22 10:26:13 +0000 | [diff] [blame] | 177 | }; |
| 178 | |
| 179 | } // namespace webrtc |
stefan@webrtc.org | 9354cc9 | 2012-06-07 08:10:14 +0000 | [diff] [blame] | 180 | |
Mirko Bonadei | 92ea95e | 2017-09-15 06:47:31 +0200 | [diff] [blame] | 181 | #endif // MODULES_RTP_RTCP_MOCKS_MOCK_RTP_RTCP_H_ |