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 11 12 /* 13 * This file includes unit tests for the RTCPSender. 14 */ 15 16 #include "testing/gmock/include/gmock/gmock.h" 17 #include "testing/gtest/include/gtest/gtest.h" 18 19 #include "webrtc/common_types.h" 20 #include "webrtc/modules/remote_bitrate_estimator/include/mock/mock_remote_bitrate_observer.h" 21 #include "webrtc/modules/remote_bitrate_estimator/include/remote_bitrate_estimator.h" 22 #include "webrtc/modules/rtp_rtcp/interface/rtp_header_parser.h" 23 #include "webrtc/modules/rtp_rtcp/interface/rtp_payload_registry.h" 24 #include "webrtc/modules/rtp_rtcp/interface/rtp_receiver.h" 25 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h" 26 #include "webrtc/modules/rtp_rtcp/source/rtcp_sender.h" 27 #include "webrtc/modules/rtp_rtcp/source/rtp_receiver_video.h" 28 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h" 29 #include "webrtc/modules/rtp_rtcp/source/rtp_utility.h" 30 31 namespace webrtc { 32 33 TEST(NACKStringBuilderTest, TestCase1) { 34 NACKStringBuilder builder; 35 builder.PushNACK(5); 36 builder.PushNACK(7); 37 builder.PushNACK(9); 38 builder.PushNACK(10); 39 builder.PushNACK(11); 40 builder.PushNACK(12); 41 builder.PushNACK(15); 42 builder.PushNACK(18); 43 builder.PushNACK(19); 44 EXPECT_EQ(std::string("5,7,9-12,15,18-19"), builder.GetResult()); 45 } 46 47 TEST(NACKStringBuilderTest, TestCase2) { 48 NACKStringBuilder builder; 49 builder.PushNACK(5); 50 builder.PushNACK(6); 51 builder.PushNACK(7); 52 builder.PushNACK(9); 53 builder.PushNACK(10); 54 builder.PushNACK(11); 55 builder.PushNACK(12); 56 builder.PushNACK(15); 57 builder.PushNACK(18); 58 builder.PushNACK(19); 59 EXPECT_EQ(std::string("5-7,9-12,15,18-19"), builder.GetResult()); 60 } 61 62 TEST(NACKStringBuilderTest, TestCase3) { 63 NACKStringBuilder builder; 64 builder.PushNACK(5); 65 builder.PushNACK(7); 66 builder.PushNACK(9); 67 builder.PushNACK(10); 68 builder.PushNACK(11); 69 builder.PushNACK(12); 70 builder.PushNACK(15); 71 builder.PushNACK(18); 72 builder.PushNACK(19); 73 builder.PushNACK(21); 74 EXPECT_EQ(std::string("5,7,9-12,15,18-19,21"), builder.GetResult()); 75 } 76 77 TEST(NACKStringBuilderTest, TestCase4) { 78 NACKStringBuilder builder; 79 builder.PushNACK(5); 80 builder.PushNACK(7); 81 builder.PushNACK(8); 82 builder.PushNACK(9); 83 builder.PushNACK(10); 84 builder.PushNACK(11); 85 builder.PushNACK(12); 86 builder.PushNACK(15); 87 builder.PushNACK(18); 88 builder.PushNACK(19); 89 EXPECT_EQ(std::string("5,7-12,15,18-19"), builder.GetResult()); 90 } 91 92 TEST(NACKStringBuilderTest, TestCase5) { 93 NACKStringBuilder builder; 94 builder.PushNACK(5); 95 builder.PushNACK(7); 96 builder.PushNACK(9); 97 builder.PushNACK(10); 98 builder.PushNACK(11); 99 builder.PushNACK(12); 100 builder.PushNACK(15); 101 builder.PushNACK(16); 102 builder.PushNACK(18); 103 builder.PushNACK(19); 104 EXPECT_EQ(std::string("5,7,9-12,15-16,18-19"), builder.GetResult()); 105 } 106 107 TEST(NACKStringBuilderTest, TestCase6) { 108 NACKStringBuilder builder; 109 builder.PushNACK(5); 110 builder.PushNACK(7); 111 builder.PushNACK(9); 112 builder.PushNACK(10); 113 builder.PushNACK(11); 114 builder.PushNACK(12); 115 builder.PushNACK(15); 116 builder.PushNACK(16); 117 builder.PushNACK(17); 118 builder.PushNACK(18); 119 builder.PushNACK(19); 120 EXPECT_EQ(std::string("5,7,9-12,15-19"), builder.GetResult()); 121 } 122 123 TEST(NACKStringBuilderTest, TestCase7) { 124 NACKStringBuilder builder; 125 builder.PushNACK(5); 126 builder.PushNACK(6); 127 builder.PushNACK(7); 128 builder.PushNACK(8); 129 builder.PushNACK(11); 130 builder.PushNACK(12); 131 builder.PushNACK(13); 132 builder.PushNACK(14); 133 builder.PushNACK(15); 134 EXPECT_EQ(std::string("5-8,11-15"), builder.GetResult()); 135 } 136 137 TEST(NACKStringBuilderTest, TestCase8) { 138 NACKStringBuilder builder; 139 builder.PushNACK(5); 140 builder.PushNACK(7); 141 builder.PushNACK(9); 142 builder.PushNACK(11); 143 builder.PushNACK(15); 144 builder.PushNACK(17); 145 builder.PushNACK(19); 146 EXPECT_EQ(std::string("5,7,9,11,15,17,19"), builder.GetResult()); 147 } 148 149 TEST(NACKStringBuilderTest, TestCase9) { 150 NACKStringBuilder builder; 151 builder.PushNACK(5); 152 builder.PushNACK(6); 153 builder.PushNACK(7); 154 builder.PushNACK(8); 155 builder.PushNACK(9); 156 builder.PushNACK(10); 157 builder.PushNACK(11); 158 builder.PushNACK(12); 159 EXPECT_EQ(std::string("5-12"), builder.GetResult()); 160 } 161 162 TEST(NACKStringBuilderTest, TestCase10) { 163 NACKStringBuilder builder; 164 builder.PushNACK(5); 165 EXPECT_EQ(std::string("5"), builder.GetResult()); 166 } 167 168 TEST(NACKStringBuilderTest, TestCase11) { 169 NACKStringBuilder builder; 170 EXPECT_EQ(std::string(""), builder.GetResult()); 171 } 172 173 TEST(NACKStringBuilderTest, TestCase12) { 174 NACKStringBuilder builder; 175 builder.PushNACK(5); 176 builder.PushNACK(6); 177 EXPECT_EQ(std::string("5-6"), builder.GetResult()); 178 } 179 180 TEST(NACKStringBuilderTest, TestCase13) { 181 NACKStringBuilder builder; 182 builder.PushNACK(5); 183 builder.PushNACK(6); 184 builder.PushNACK(9); 185 EXPECT_EQ(std::string("5-6,9"), builder.GetResult()); 186 } 187 188 void CreateRtpPacket(const bool marker_bit, const uint8_t payload, 189 const uint16_t seq_num, const uint32_t timestamp, 190 const uint32_t ssrc, uint8_t* array, 191 uint16_t* cur_pos) { 192 ASSERT_TRUE(payload <= 127); 193 array[(*cur_pos)++] = 0x80; 194 array[(*cur_pos)++] = payload | (marker_bit ? 0x80 : 0); 195 array[(*cur_pos)++] = seq_num >> 8; 196 array[(*cur_pos)++] = seq_num; 197 array[(*cur_pos)++] = timestamp >> 24; 198 array[(*cur_pos)++] = timestamp >> 16; 199 array[(*cur_pos)++] = timestamp >> 8; 200 array[(*cur_pos)++] = timestamp; 201 array[(*cur_pos)++] = ssrc >> 24; 202 array[(*cur_pos)++] = ssrc >> 16; 203 array[(*cur_pos)++] = ssrc >> 8; 204 array[(*cur_pos)++] = ssrc; 205 // VP8 payload header 206 array[(*cur_pos)++] = 0x90; // X bit = 1 207 array[(*cur_pos)++] = 0x20; // T bit = 1 208 array[(*cur_pos)++] = 0x00; // TID = 0 209 array[(*cur_pos)++] = 0x00; // Key frame 210 array[(*cur_pos)++] = 0x00; 211 array[(*cur_pos)++] = 0x00; 212 array[(*cur_pos)++] = 0x9d; 213 array[(*cur_pos)++] = 0x01; 214 array[(*cur_pos)++] = 0x2a; 215 array[(*cur_pos)++] = 128; 216 array[(*cur_pos)++] = 0; 217 array[(*cur_pos)++] = 96; 218 array[(*cur_pos)++] = 0; 219 } 220 221 class TestTransport : public Transport, 222 public NullRtpData { 223 public: 224 TestTransport() 225 : rtcp_receiver_(NULL) { 226 } 227 void SetRTCPReceiver(RTCPReceiver* rtcp_receiver) { 228 rtcp_receiver_ = rtcp_receiver; 229 } 230 virtual int SendPacket(int /*ch*/, const void* /*data*/, int /*len*/) { 231 return -1; 232 } 233 234 virtual int SendRTCPPacket(int /*ch*/, const void *packet, int packet_len) { 235 RTCPUtility::RTCPParserV2 rtcpParser((uint8_t*)packet, 236 (int32_t)packet_len, 237 true); // Allow non-compound RTCP 238 239 EXPECT_TRUE(rtcpParser.IsValid()); 240 RTCPHelp::RTCPPacketInformation rtcpPacketInformation; 241 EXPECT_EQ(0, rtcp_receiver_->IncomingRTCPPacket(rtcpPacketInformation, 242 &rtcpParser)); 243 rtcp_packet_info_.rtcpPacketTypeFlags = 244 rtcpPacketInformation.rtcpPacketTypeFlags; 245 rtcp_packet_info_.remoteSSRC = rtcpPacketInformation.remoteSSRC; 246 rtcp_packet_info_.applicationSubType = 247 rtcpPacketInformation.applicationSubType; 248 rtcp_packet_info_.applicationName = rtcpPacketInformation.applicationName; 249 rtcp_packet_info_.report_blocks = rtcpPacketInformation.report_blocks; 250 rtcp_packet_info_.rtt = rtcpPacketInformation.rtt; 251 rtcp_packet_info_.interArrivalJitter = 252 rtcpPacketInformation.interArrivalJitter; 253 rtcp_packet_info_.sliPictureId = rtcpPacketInformation.sliPictureId; 254 rtcp_packet_info_.rpsiPictureId = rtcpPacketInformation.rpsiPictureId; 255 rtcp_packet_info_.receiverEstimatedMaxBitrate = 256 rtcpPacketInformation.receiverEstimatedMaxBitrate; 257 rtcp_packet_info_.ntp_secs = rtcpPacketInformation.ntp_secs; 258 rtcp_packet_info_.ntp_frac = rtcpPacketInformation.ntp_frac; 259 rtcp_packet_info_.rtp_timestamp = rtcpPacketInformation.rtp_timestamp; 260 261 return packet_len; 262 } 263 264 virtual int OnReceivedPayloadData(const uint8_t* payloadData, 265 const uint16_t payloadSize, 266 const WebRtcRTPHeader* rtpHeader) { 267 return 0; 268 } 269 RTCPReceiver* rtcp_receiver_; 270 RTCPHelp::RTCPPacketInformation rtcp_packet_info_; 271 }; 272 273 class RtcpSenderTest : public ::testing::Test { 274 protected: 275 static const uint32_t kRemoteBitrateEstimatorMinBitrateBps = 30000; 276 277 RtcpSenderTest() 278 : over_use_detector_options_(), 279 clock_(1335900000), 280 rtp_payload_registry_(new RTPPayloadRegistry( 281 RTPPayloadStrategy::CreateStrategy(false))), 282 remote_bitrate_observer_(), 283 remote_bitrate_estimator_( 284 RemoteBitrateEstimatorFactory().Create( 285 &remote_bitrate_observer_, 286 &clock_, 287 kMimdControl, 288 kRemoteBitrateEstimatorMinBitrateBps)), 289 receive_statistics_(ReceiveStatistics::Create(&clock_)) { 290 test_transport_ = new TestTransport(); 291 292 RtpRtcp::Configuration configuration; 293 configuration.id = 0; 294 configuration.audio = false; 295 configuration.clock = &clock_; 296 configuration.outgoing_transport = test_transport_; 297 configuration.remote_bitrate_estimator = remote_bitrate_estimator_.get(); 298 299 rtp_rtcp_impl_ = new ModuleRtpRtcpImpl(configuration); 300 rtp_receiver_.reset(RtpReceiver::CreateVideoReceiver( 301 0, &clock_, test_transport_, NULL, rtp_payload_registry_.get())); 302 rtcp_sender_ = 303 new RTCPSender(0, false, &clock_, receive_statistics_.get()); 304 rtcp_receiver_ = new RTCPReceiver(0, &clock_, rtp_rtcp_impl_); 305 test_transport_->SetRTCPReceiver(rtcp_receiver_); 306 // Initialize 307 EXPECT_EQ(0, rtcp_sender_->Init()); 308 EXPECT_EQ(0, rtcp_sender_->RegisterSendTransport(test_transport_)); 309 } 310 ~RtcpSenderTest() { 311 delete rtcp_sender_; 312 delete rtcp_receiver_; 313 delete rtp_rtcp_impl_; 314 delete test_transport_; 315 } 316 317 // Helper function: Incoming RTCP has a specific packet type. 318 bool gotPacketType(RTCPPacketType packet_type) { 319 return ((test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags) & 320 packet_type) != 0U; 321 } 322 323 OverUseDetectorOptions over_use_detector_options_; 324 SimulatedClock clock_; 325 scoped_ptr<RTPPayloadRegistry> rtp_payload_registry_; 326 scoped_ptr<RtpReceiver> rtp_receiver_; 327 ModuleRtpRtcpImpl* rtp_rtcp_impl_; 328 RTCPSender* rtcp_sender_; 329 RTCPReceiver* rtcp_receiver_; 330 TestTransport* test_transport_; 331 MockRemoteBitrateObserver remote_bitrate_observer_; 332 scoped_ptr<RemoteBitrateEstimator> remote_bitrate_estimator_; 333 scoped_ptr<ReceiveStatistics> receive_statistics_; 334 335 enum {kMaxPacketLength = 1500}; 336 uint8_t packet_[kMaxPacketLength]; 337 }; 338 339 TEST_F(RtcpSenderTest, RtcpOff) { 340 EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpOff)); 341 RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_); 342 EXPECT_EQ(-1, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr)); 343 } 344 345 TEST_F(RtcpSenderTest, IJStatus) { 346 ASSERT_FALSE(rtcp_sender_->IJ()); 347 EXPECT_EQ(0, rtcp_sender_->SetIJStatus(true)); 348 ASSERT_TRUE(rtcp_sender_->IJ()); 349 } 350 351 TEST_F(RtcpSenderTest, TestCompound) { 352 const bool marker_bit = false; 353 const uint8_t payload = 100; 354 const uint16_t seq_num = 11111; 355 const uint32_t timestamp = 1234567; 356 const uint32_t ssrc = 0x11111111; 357 uint16_t packet_length = 0; 358 CreateRtpPacket(marker_bit, payload, seq_num, timestamp, ssrc, packet_, 359 &packet_length); 360 EXPECT_EQ(25, packet_length); 361 362 VideoCodec codec_inst; 363 strncpy(codec_inst.plName, "VP8", webrtc::kPayloadNameSize - 1); 364 codec_inst.codecType = webrtc::kVideoCodecVP8; 365 codec_inst.plType = payload; 366 EXPECT_EQ(0, rtp_receiver_->RegisterReceivePayload(codec_inst.plName, 367 codec_inst.plType, 368 90000, 369 0, 370 codec_inst.maxBitrate)); 371 372 // Make sure RTP packet has been received. 373 scoped_ptr<RtpHeaderParser> parser(RtpHeaderParser::Create()); 374 RTPHeader header; 375 EXPECT_TRUE(parser->Parse(packet_, packet_length, &header)); 376 PayloadUnion payload_specific; 377 EXPECT_TRUE(rtp_payload_registry_->GetPayloadSpecifics(header.payloadType, 378 &payload_specific)); 379 receive_statistics_->IncomingPacket(header, packet_length, false); 380 EXPECT_TRUE(rtp_receiver_->IncomingRtpPacket(header, packet_, packet_length, 381 payload_specific, true)); 382 383 EXPECT_EQ(0, rtcp_sender_->SetIJStatus(true)); 384 EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound)); 385 RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_); 386 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRr)); 387 388 // Transmission time offset packet should be received. 389 ASSERT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & 390 kRtcpTransmissionTimeOffset); 391 } 392 393 TEST_F(RtcpSenderTest, TestCompound_NoRtpReceived) { 394 EXPECT_EQ(0, rtcp_sender_->SetIJStatus(true)); 395 EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound)); 396 RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_); 397 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpRr)); 398 399 // Transmission time offset packet should not be received. 400 ASSERT_FALSE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & 401 kRtcpTransmissionTimeOffset); 402 } 403 404 TEST_F(RtcpSenderTest, TestXrReceiverReferenceTime) { 405 EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound)); 406 RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_); 407 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false)); 408 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); 409 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); 410 411 EXPECT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & 412 kRtcpXrReceiverReferenceTime); 413 } 414 415 TEST_F(RtcpSenderTest, TestNoXrReceiverReferenceTimeIfSending) { 416 EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound)); 417 RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_); 418 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, true)); 419 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); 420 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); 421 422 EXPECT_FALSE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & 423 kRtcpXrReceiverReferenceTime); 424 } 425 426 TEST_F(RtcpSenderTest, TestNoXrReceiverReferenceTimeIfNotEnabled) { 427 EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound)); 428 RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_); 429 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false)); 430 rtcp_sender_->SendRtcpXrReceiverReferenceTime(false); 431 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); 432 433 EXPECT_FALSE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & 434 kRtcpXrReceiverReferenceTime); 435 } 436 437 TEST_F(RtcpSenderTest, TestSendTimeOfXrRrReport) { 438 EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound)); 439 RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_); 440 EXPECT_EQ(0, rtcp_sender_->SetSendingStatus(feedback_state, false)); 441 rtcp_sender_->SendRtcpXrReceiverReferenceTime(true); 442 uint32_t ntp_sec; 443 uint32_t ntp_frac; 444 clock_.CurrentNtp(ntp_sec, ntp_frac); 445 uint32_t initial_mid_ntp = RTCPUtility::MidNtp(ntp_sec, ntp_frac); 446 447 // No packet sent. 448 int64_t time_ms; 449 EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms)); 450 451 // Send XR RR packets. 452 for (int i = 0; i <= RTCP_NUMBER_OF_SR; ++i) { 453 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpReport)); 454 EXPECT_TRUE(test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags & 455 kRtcpXrReceiverReferenceTime); 456 457 clock_.CurrentNtp(ntp_sec, ntp_frac); 458 uint32_t mid_ntp = RTCPUtility::MidNtp(ntp_sec, ntp_frac); 459 EXPECT_TRUE(rtcp_sender_->SendTimeOfXrRrReport(mid_ntp, &time_ms)); 460 EXPECT_EQ(clock_.CurrentNtpInMilliseconds(), time_ms); 461 clock_.AdvanceTimeMilliseconds(1000); 462 } 463 464 // The first report should no longer be stored. 465 EXPECT_FALSE(rtcp_sender_->SendTimeOfXrRrReport(initial_mid_ntp, &time_ms)); 466 } 467 468 // This test is written to verify actual behaviour. It does not seem 469 // to make much sense to send an empty TMMBN, since there is no place 470 // to put an actual limit here. It's just information that no limit 471 // is set, which is kind of the starting assumption. 472 // See http://code.google.com/p/webrtc/issues/detail?id=468 for one 473 // situation where this caused confusion. 474 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndEmpty) { 475 EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound)); 476 TMMBRSet bounding_set; 477 EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3)); 478 ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags); 479 RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_); 480 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state,kRtcpSr)); 481 // We now expect the packet to show up in the rtcp_packet_info_ of 482 // test_transport_. 483 ASSERT_NE(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags); 484 EXPECT_TRUE(gotPacketType(kRtcpTmmbn)); 485 TMMBRSet* incoming_set = NULL; 486 bool owner = false; 487 // The BoundingSet function returns the number of members of the 488 // bounding set, and touches the incoming set only if there's > 1. 489 EXPECT_EQ(0, test_transport_->rtcp_receiver_->BoundingSet(owner, 490 incoming_set)); 491 } 492 493 TEST_F(RtcpSenderTest, SendsTmmbnIfSetAndValid) { 494 EXPECT_EQ(0, rtcp_sender_->SetRTCPStatus(kRtcpCompound)); 495 TMMBRSet bounding_set; 496 bounding_set.VerifyAndAllocateSet(1); 497 const uint32_t kSourceSsrc = 12345; 498 bounding_set.AddEntry(32768, 0, kSourceSsrc); 499 500 EXPECT_EQ(0, rtcp_sender_->SetTMMBN(&bounding_set, 3)); 501 ASSERT_EQ(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags); 502 RTCPSender::FeedbackState feedback_state(rtp_rtcp_impl_); 503 EXPECT_EQ(0, rtcp_sender_->SendRTCP(feedback_state, kRtcpSr)); 504 // We now expect the packet to show up in the rtcp_packet_info_ of 505 // test_transport_. 506 ASSERT_NE(0U, test_transport_->rtcp_packet_info_.rtcpPacketTypeFlags); 507 EXPECT_TRUE(gotPacketType(kRtcpTmmbn)); 508 TMMBRSet incoming_set; 509 bool owner = false; 510 // We expect 1 member of the incoming set. 511 EXPECT_EQ(1, test_transport_->rtcp_receiver_->BoundingSet(owner, 512 &incoming_set)); 513 EXPECT_EQ(kSourceSsrc, incoming_set.Ssrc(0)); 514 } 515 } // namespace webrtc 516
