1// Copyright 2013 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "base/memory/scoped_ptr.h" 6#include "base/test/simple_test_tick_clock.h" 7#include "media/cast/cast_defines.h" 8#include "media/cast/cast_environment.h" 9#include "media/cast/rtcp/receiver_rtcp_event_subscriber.h" 10#include "media/cast/rtcp/rtcp_sender.h" 11#include "media/cast/rtcp/rtcp_utility.h" 12#include "media/cast/rtcp/test_rtcp_packet_builder.h" 13#include "media/cast/test/fake_single_thread_task_runner.h" 14#include "media/cast/transport/cast_transport_defines.h" 15#include "media/cast/transport/pacing/paced_sender.h" 16#include "testing/gmock/include/gmock/gmock.h" 17 18namespace media { 19namespace cast { 20 21namespace { 22static const uint32 kSendingSsrc = 0x12345678; 23static const uint32 kMediaSsrc = 0x87654321; 24static const int16 kDefaultDelay = 100; 25static const std::string kCName("test@10.1.1.1"); 26 27transport::RtcpReportBlock GetReportBlock() { 28 transport::RtcpReportBlock report_block; 29 // Initialize remote_ssrc to a "clearly illegal" value. 30 report_block.remote_ssrc = 0xDEAD; 31 report_block.media_ssrc = kMediaSsrc; // SSRC of the RTP packet sender. 32 report_block.fraction_lost = kLoss >> 24; 33 report_block.cumulative_lost = kLoss; // 24 bits valid. 34 report_block.extended_high_sequence_number = kExtendedMax; 35 report_block.jitter = kTestJitter; 36 report_block.last_sr = kLastSr; 37 report_block.delay_since_last_sr = kDelayLastSr; 38 return report_block; 39} 40 41} // namespace 42 43class TestRtcpTransport : public transport::PacedPacketSender { 44 public: 45 TestRtcpTransport() : packet_count_(0) {} 46 47 virtual bool SendRtcpPacket(uint32 ssrc, 48 transport::PacketRef packet) OVERRIDE { 49 EXPECT_EQ(expected_packet_.size(), packet->data.size()); 50 EXPECT_EQ(0, memcmp(expected_packet_.data(), 51 packet->data.data(), 52 packet->data.size())); 53 packet_count_++; 54 return true; 55 } 56 57 virtual bool SendPackets( 58 const transport::SendPacketVector& packets) OVERRIDE { 59 return false; 60 } 61 virtual bool ResendPackets( 62 const transport::SendPacketVector& packets, 63 base::TimeDelta dedupe_window) OVERRIDE { 64 return false; 65 } 66 67 virtual void CancelSendingPacket( 68 const transport::PacketKey& packet_key) OVERRIDE { 69 } 70 71 void SetExpectedRtcpPacket(scoped_ptr<Packet> packet) { 72 expected_packet_.swap(*packet); 73 } 74 75 int packet_count() const { return packet_count_; } 76 77 private: 78 Packet expected_packet_; 79 int packet_count_; 80 81 DISALLOW_COPY_AND_ASSIGN(TestRtcpTransport); 82}; 83 84class RtcpSenderTest : public ::testing::Test { 85 protected: 86 RtcpSenderTest() 87 : testing_clock_(new base::SimpleTestTickClock()), 88 task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)), 89 cast_environment_(new CastEnvironment( 90 scoped_ptr<base::TickClock>(testing_clock_).Pass(), 91 task_runner_, 92 task_runner_, 93 task_runner_)), 94 rtcp_sender_(new RtcpSender(cast_environment_, 95 &test_transport_, 96 kSendingSsrc, 97 kCName)) {} 98 99 base::SimpleTestTickClock* testing_clock_; // Owned by CastEnvironment. 100 TestRtcpTransport test_transport_; 101 scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_; 102 scoped_refptr<CastEnvironment> cast_environment_; 103 scoped_ptr<RtcpSender> rtcp_sender_; 104 105 DISALLOW_COPY_AND_ASSIGN(RtcpSenderTest); 106}; 107 108TEST_F(RtcpSenderTest, RtcpReceiverReport) { 109 // Empty receiver report + c_name. 110 TestRtcpPacketBuilder p1; 111 p1.AddRr(kSendingSsrc, 0); 112 p1.AddSdesCname(kSendingSsrc, kCName); 113 test_transport_.SetExpectedRtcpPacket(p1.GetPacket()); 114 115 rtcp_sender_->SendRtcpFromRtpReceiver( 116 transport::kRtcpRr, NULL, NULL, NULL, NULL, kDefaultDelay); 117 118 EXPECT_EQ(1, test_transport_.packet_count()); 119 120 // Receiver report with report block + c_name. 121 TestRtcpPacketBuilder p2; 122 p2.AddRr(kSendingSsrc, 1); 123 p2.AddRb(kMediaSsrc); 124 p2.AddSdesCname(kSendingSsrc, kCName); 125 test_transport_.SetExpectedRtcpPacket(p2.GetPacket().Pass()); 126 127 transport::RtcpReportBlock report_block = GetReportBlock(); 128 129 rtcp_sender_->SendRtcpFromRtpReceiver( 130 transport::kRtcpRr, &report_block, NULL, NULL, NULL, kDefaultDelay); 131 132 EXPECT_EQ(2, test_transport_.packet_count()); 133} 134 135TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtr) { 136 // Receiver report with report block + c_name. 137 TestRtcpPacketBuilder p; 138 p.AddRr(kSendingSsrc, 1); 139 p.AddRb(kMediaSsrc); 140 p.AddSdesCname(kSendingSsrc, kCName); 141 p.AddXrHeader(kSendingSsrc); 142 p.AddXrRrtrBlock(); 143 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); 144 145 transport::RtcpReportBlock report_block = GetReportBlock(); 146 147 RtcpReceiverReferenceTimeReport rrtr; 148 rrtr.ntp_seconds = kNtpHigh; 149 rrtr.ntp_fraction = kNtpLow; 150 151 rtcp_sender_->SendRtcpFromRtpReceiver( 152 transport::kRtcpRr | transport::kRtcpRrtr, 153 &report_block, 154 &rrtr, 155 NULL, 156 NULL, 157 kDefaultDelay); 158 159 EXPECT_EQ(1, test_transport_.packet_count()); 160} 161 162TEST_F(RtcpSenderTest, RtcpReceiverReportWithCast) { 163 // Receiver report with report block + c_name. 164 TestRtcpPacketBuilder p; 165 p.AddRr(kSendingSsrc, 1); 166 p.AddRb(kMediaSsrc); 167 p.AddSdesCname(kSendingSsrc, kCName); 168 p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay); 169 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); 170 171 transport::RtcpReportBlock report_block = GetReportBlock(); 172 173 RtcpCastMessage cast_message(kMediaSsrc); 174 cast_message.ack_frame_id_ = kAckFrameId; 175 PacketIdSet missing_packets; 176 cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets; 177 178 missing_packets.insert(kLostPacketId1); 179 missing_packets.insert(kLostPacketId2); 180 missing_packets.insert(kLostPacketId3); 181 cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = 182 missing_packets; 183 184 rtcp_sender_->SendRtcpFromRtpReceiver( 185 transport::kRtcpRr | transport::kRtcpCast, 186 &report_block, 187 NULL, 188 &cast_message, 189 NULL, 190 kDefaultDelay); 191 192 EXPECT_EQ(1, test_transport_.packet_count()); 193} 194 195TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtraAndCastMessage) { 196 TestRtcpPacketBuilder p; 197 p.AddRr(kSendingSsrc, 1); 198 p.AddRb(kMediaSsrc); 199 p.AddSdesCname(kSendingSsrc, kCName); 200 p.AddXrHeader(kSendingSsrc); 201 p.AddXrRrtrBlock(); 202 p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay); 203 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); 204 205 transport::RtcpReportBlock report_block = GetReportBlock(); 206 207 RtcpReceiverReferenceTimeReport rrtr; 208 rrtr.ntp_seconds = kNtpHigh; 209 rrtr.ntp_fraction = kNtpLow; 210 211 RtcpCastMessage cast_message(kMediaSsrc); 212 cast_message.ack_frame_id_ = kAckFrameId; 213 PacketIdSet missing_packets; 214 cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets; 215 216 missing_packets.insert(kLostPacketId1); 217 missing_packets.insert(kLostPacketId2); 218 missing_packets.insert(kLostPacketId3); 219 cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = 220 missing_packets; 221 222 rtcp_sender_->SendRtcpFromRtpReceiver( 223 transport::kRtcpRr | transport::kRtcpRrtr | transport::kRtcpCast, 224 &report_block, 225 &rrtr, 226 &cast_message, 227 NULL, 228 kDefaultDelay); 229 230 EXPECT_EQ(1, test_transport_.packet_count()); 231} 232 233TEST_F(RtcpSenderTest, RtcpReceiverReportWithRrtrCastMessageAndLog) { 234 static const uint32 kTimeBaseMs = 12345678; 235 static const uint32 kTimeDelayMs = 10; 236 237 TestRtcpPacketBuilder p; 238 p.AddRr(kSendingSsrc, 1); 239 p.AddRb(kMediaSsrc); 240 p.AddSdesCname(kSendingSsrc, kCName); 241 p.AddXrHeader(kSendingSsrc); 242 p.AddXrRrtrBlock(); 243 p.AddCast(kSendingSsrc, kMediaSsrc, kDefaultDelay); 244 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); 245 246 transport::RtcpReportBlock report_block = GetReportBlock(); 247 248 RtcpReceiverReferenceTimeReport rrtr; 249 rrtr.ntp_seconds = kNtpHigh; 250 rrtr.ntp_fraction = kNtpLow; 251 252 RtcpCastMessage cast_message(kMediaSsrc); 253 cast_message.ack_frame_id_ = kAckFrameId; 254 PacketIdSet missing_packets; 255 cast_message.missing_frames_and_packets_[kLostFrameId] = missing_packets; 256 257 missing_packets.insert(kLostPacketId1); 258 missing_packets.insert(kLostPacketId2); 259 missing_packets.insert(kLostPacketId3); 260 cast_message.missing_frames_and_packets_[kFrameIdWithLostPackets] = 261 missing_packets; 262 263 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); 264 ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; 265 266 rtcp_sender_->SendRtcpFromRtpReceiver( 267 transport::kRtcpRr | transport::kRtcpRrtr | transport::kRtcpCast | 268 transport::kRtcpReceiverLog, 269 &report_block, 270 &rrtr, 271 &cast_message, 272 &rtcp_events, 273 kDefaultDelay); 274 275 base::SimpleTestTickClock testing_clock; 276 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); 277 278 p.AddReceiverLog(kSendingSsrc); 279 p.AddReceiverFrameLog(kRtpTimestamp, 2, kTimeBaseMs); 280 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); 281 p.AddReceiverEventLog(kLostPacketId1, PACKET_RECEIVED, kTimeDelayMs); 282 283 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); 284 285 FrameEvent frame_event; 286 frame_event.rtp_timestamp = kRtpTimestamp; 287 frame_event.type = FRAME_ACK_SENT; 288 frame_event.media_type = VIDEO_EVENT; 289 frame_event.timestamp = testing_clock.NowTicks(); 290 event_subscriber.OnReceiveFrameEvent(frame_event); 291 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); 292 293 PacketEvent packet_event; 294 packet_event.rtp_timestamp = kRtpTimestamp; 295 packet_event.type = PACKET_RECEIVED; 296 packet_event.media_type = VIDEO_EVENT; 297 packet_event.timestamp = testing_clock.NowTicks(); 298 packet_event.packet_id = kLostPacketId1; 299 event_subscriber.OnReceivePacketEvent(packet_event); 300 event_subscriber.GetRtcpEventsAndReset(&rtcp_events); 301 EXPECT_EQ(2u, rtcp_events.size()); 302 303 rtcp_sender_->SendRtcpFromRtpReceiver( 304 transport::kRtcpRr | transport::kRtcpRrtr | transport::kRtcpCast | 305 transport::kRtcpReceiverLog, 306 &report_block, 307 &rrtr, 308 &cast_message, 309 &rtcp_events, 310 kDefaultDelay); 311 312 EXPECT_EQ(2, test_transport_.packet_count()); 313} 314 315TEST_F(RtcpSenderTest, RtcpReceiverReportWithOversizedFrameLog) { 316 static const uint32 kTimeBaseMs = 12345678; 317 static const uint32 kTimeDelayMs = 10; 318 319 TestRtcpPacketBuilder p; 320 p.AddRr(kSendingSsrc, 1); 321 p.AddRb(kMediaSsrc); 322 p.AddSdesCname(kSendingSsrc, kCName); 323 324 transport::RtcpReportBlock report_block = GetReportBlock(); 325 326 base::SimpleTestTickClock testing_clock; 327 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); 328 329 p.AddReceiverLog(kSendingSsrc); 330 331 int remaining_bytes = kMaxReceiverLogBytes; 332 remaining_bytes -= kRtcpCastLogHeaderSize; 333 334 remaining_bytes -= kRtcpReceiverFrameLogSize; 335 int num_events = remaining_bytes / kRtcpReceiverEventLogSize; 336 EXPECT_LE(num_events, static_cast<int>(kRtcpMaxReceiverLogMessages)); 337 // Only the last |num_events| events are sent due to receiver log size cap. 338 p.AddReceiverFrameLog( 339 kRtpTimestamp + 2345, 340 num_events, 341 kTimeBaseMs + (kRtcpMaxReceiverLogMessages - num_events) * kTimeDelayMs); 342 for (int i = 0; i < num_events; i++) { 343 p.AddReceiverEventLog( 344 kLostPacketId1, PACKET_RECEIVED, 345 static_cast<uint16>(kTimeDelayMs * i)); 346 } 347 348 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); 349 350 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); 351 FrameEvent frame_event; 352 frame_event.rtp_timestamp = kRtpTimestamp; 353 frame_event.type = FRAME_ACK_SENT; 354 frame_event.media_type = VIDEO_EVENT; 355 frame_event.timestamp = testing_clock.NowTicks(); 356 event_subscriber.OnReceiveFrameEvent(frame_event); 357 358 for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) { 359 PacketEvent packet_event; 360 packet_event.rtp_timestamp = kRtpTimestamp + 2345; 361 packet_event.type = PACKET_RECEIVED; 362 packet_event.media_type = VIDEO_EVENT; 363 packet_event.timestamp = testing_clock.NowTicks(); 364 packet_event.packet_id = kLostPacketId1; 365 event_subscriber.OnReceivePacketEvent(packet_event); 366 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); 367 } 368 369 ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; 370 event_subscriber.GetRtcpEventsAndReset(&rtcp_events); 371 372 rtcp_sender_->SendRtcpFromRtpReceiver( 373 transport::kRtcpRr | transport::kRtcpReceiverLog, 374 &report_block, 375 NULL, 376 NULL, 377 &rtcp_events, 378 kDefaultDelay); 379 380 EXPECT_EQ(1, test_transport_.packet_count()); 381} 382 383TEST_F(RtcpSenderTest, RtcpReceiverReportWithTooManyLogFrames) { 384 static const uint32 kTimeBaseMs = 12345678; 385 static const uint32 kTimeDelayMs = 10; 386 387 TestRtcpPacketBuilder p; 388 p.AddRr(kSendingSsrc, 1); 389 p.AddRb(kMediaSsrc); 390 p.AddSdesCname(kSendingSsrc, kCName); 391 392 transport::RtcpReportBlock report_block = GetReportBlock(); 393 394 base::SimpleTestTickClock testing_clock; 395 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); 396 397 p.AddReceiverLog(kSendingSsrc); 398 399 int remaining_bytes = kMaxReceiverLogBytes; 400 remaining_bytes -= kRtcpCastLogHeaderSize; 401 402 int num_events = 403 remaining_bytes / (kRtcpReceiverFrameLogSize + kRtcpReceiverEventLogSize); 404 405 // The last |num_events| events are sent due to receiver log size cap. 406 for (size_t i = kRtcpMaxReceiverLogMessages - num_events; 407 i < kRtcpMaxReceiverLogMessages; 408 ++i) { 409 p.AddReceiverFrameLog(kRtpTimestamp + i, 1, kTimeBaseMs + i * kTimeDelayMs); 410 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); 411 } 412 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); 413 414 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); 415 416 for (size_t i = 0; i < kRtcpMaxReceiverLogMessages; ++i) { 417 FrameEvent frame_event; 418 frame_event.rtp_timestamp = kRtpTimestamp + static_cast<int>(i); 419 frame_event.type = FRAME_ACK_SENT; 420 frame_event.media_type = VIDEO_EVENT; 421 frame_event.timestamp = testing_clock.NowTicks(); 422 event_subscriber.OnReceiveFrameEvent(frame_event); 423 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeDelayMs)); 424 } 425 426 ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; 427 event_subscriber.GetRtcpEventsAndReset(&rtcp_events); 428 429 rtcp_sender_->SendRtcpFromRtpReceiver( 430 transport::kRtcpRr | transport::kRtcpReceiverLog, 431 &report_block, 432 NULL, 433 NULL, 434 &rtcp_events, 435 kDefaultDelay); 436 437 EXPECT_EQ(1, test_transport_.packet_count()); 438} 439 440TEST_F(RtcpSenderTest, RtcpReceiverReportWithOldLogFrames) { 441 static const uint32 kTimeBaseMs = 12345678; 442 443 TestRtcpPacketBuilder p; 444 p.AddRr(kSendingSsrc, 1); 445 p.AddRb(kMediaSsrc); 446 p.AddSdesCname(kSendingSsrc, kCName); 447 448 transport::RtcpReportBlock report_block = GetReportBlock(); 449 450 base::SimpleTestTickClock testing_clock; 451 testing_clock.Advance(base::TimeDelta::FromMilliseconds(kTimeBaseMs)); 452 453 p.AddReceiverLog(kSendingSsrc); 454 455 // Log 11 events for a single frame, each |kTimeBetweenEventsMs| apart. 456 // Only last 10 events will be sent because the first event is more than 457 // 4095 milliseconds away from latest event. 458 const int kTimeBetweenEventsMs = 410; 459 p.AddReceiverFrameLog(kRtpTimestamp, 10, kTimeBaseMs + kTimeBetweenEventsMs); 460 for (int i = 0; i < 10; ++i) { 461 p.AddReceiverEventLog(0, FRAME_ACK_SENT, i * kTimeBetweenEventsMs); 462 } 463 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); 464 465 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); 466 for (int i = 0; i < 11; ++i) { 467 FrameEvent frame_event; 468 frame_event.rtp_timestamp = kRtpTimestamp; 469 frame_event.type = FRAME_ACK_SENT; 470 frame_event.media_type = VIDEO_EVENT; 471 frame_event.timestamp = testing_clock.NowTicks(); 472 event_subscriber.OnReceiveFrameEvent(frame_event); 473 testing_clock.Advance( 474 base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs)); 475 } 476 477 ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; 478 event_subscriber.GetRtcpEventsAndReset(&rtcp_events); 479 480 rtcp_sender_->SendRtcpFromRtpReceiver( 481 transport::kRtcpRr | transport::kRtcpReceiverLog, 482 &report_block, 483 NULL, 484 NULL, 485 &rtcp_events, 486 kDefaultDelay); 487 488 EXPECT_EQ(1, test_transport_.packet_count()); 489} 490 491TEST_F(RtcpSenderTest, RtcpReceiverReportRedundancy) { 492 uint32 time_base_ms = 12345678; 493 int kTimeBetweenEventsMs = 10; 494 495 transport::RtcpReportBlock report_block = GetReportBlock(); 496 497 base::SimpleTestTickClock testing_clock; 498 testing_clock.Advance(base::TimeDelta::FromMilliseconds(time_base_ms)); 499 500 ReceiverRtcpEventSubscriber event_subscriber(500, VIDEO_EVENT); 501 size_t packet_count = kReceiveLogMessageHistorySize + 10; 502 for (size_t i = 0; i < packet_count; i++) { 503 TestRtcpPacketBuilder p; 504 p.AddRr(kSendingSsrc, 1); 505 p.AddRb(kMediaSsrc); 506 p.AddSdesCname(kSendingSsrc, kCName); 507 508 p.AddReceiverLog(kSendingSsrc); 509 510 if (i >= kSecondRedundancyOffset) { 511 p.AddReceiverFrameLog( 512 kRtpTimestamp, 513 1, 514 time_base_ms - kSecondRedundancyOffset * kTimeBetweenEventsMs); 515 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); 516 } 517 if (i >= kFirstRedundancyOffset) { 518 p.AddReceiverFrameLog( 519 kRtpTimestamp, 520 1, 521 time_base_ms - kFirstRedundancyOffset * kTimeBetweenEventsMs); 522 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); 523 } 524 p.AddReceiverFrameLog(kRtpTimestamp, 1, time_base_ms); 525 p.AddReceiverEventLog(0, FRAME_ACK_SENT, 0); 526 527 test_transport_.SetExpectedRtcpPacket(p.GetPacket().Pass()); 528 529 FrameEvent frame_event; 530 frame_event.rtp_timestamp = kRtpTimestamp; 531 frame_event.type = FRAME_ACK_SENT; 532 frame_event.media_type = VIDEO_EVENT; 533 frame_event.timestamp = testing_clock.NowTicks(); 534 event_subscriber.OnReceiveFrameEvent(frame_event); 535 536 ReceiverRtcpEventSubscriber::RtcpEventMultiMap rtcp_events; 537 event_subscriber.GetRtcpEventsAndReset(&rtcp_events); 538 539 rtcp_sender_->SendRtcpFromRtpReceiver( 540 transport::kRtcpRr | transport::kRtcpReceiverLog, 541 &report_block, 542 NULL, 543 NULL, 544 &rtcp_events, 545 kDefaultDelay); 546 547 testing_clock.Advance( 548 base::TimeDelta::FromMilliseconds(kTimeBetweenEventsMs)); 549 time_base_ms += kTimeBetweenEventsMs; 550 } 551 552 EXPECT_EQ(static_cast<int>(packet_count), test_transport_.packet_count()); 553} 554 555} // namespace cast 556} // namespace media 557