src/media/cast/transport/pacing/paced_sender_unittest.cc

   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/test/simple_test_tick_clock.h"
   6 #include "media/cast/test/fake_single_thread_task_runner.h"
   7 #include "media/cast/transport/pacing/paced_sender.h"
   8 #include "testing/gmock/include/gmock/gmock.h"
   9
  10 namespace media {
  11 namespace cast {
  12 namespace transport {
  13
  14 using testing::_;
  15
  16 static const uint8 kValue = 123;
  17 static const size_t kSize1 = 100;
  18 static const size_t kSize2 = 101;
  19 static const size_t kSize3 = 102;
  20 static const size_t kSize4 = 103;
  21 static const size_t kNackSize = 104;
  22 static const int64 kStartMillisecond = GG_INT64_C(12345678900000);
  23
  24 class TestPacketSender : public PacketSender {
  25  public:
  26   TestPacketSender() {}
  27
  28   virtual bool SendPacket(const Packet& packet) OVERRIDE {
  29     EXPECT_FALSE(expected_packet_size_.empty());
  30     size_t expected_packet_size = expected_packet_size_.front();
  31     expected_packet_size_.pop_front();
  32     EXPECT_EQ(expected_packet_size, packet.size());
  33     return true;
  34   }
  35
  36   void AddExpectedSize(int expected_packet_size, int repeat_count) {
  37     for (int i = 0; i < repeat_count; ++i) {
  38       expected_packet_size_.push_back(expected_packet_size);
  39     }
  40   }
  41
  42  private:
  43   std::list<int> expected_packet_size_;
  44
  45   DISALLOW_COPY_AND_ASSIGN(TestPacketSender);
  46 };
  47
  48 class PacedSenderTest : public ::testing::Test {
  49  protected:
  50   PacedSenderTest() {
  51     testing_clock_.Advance(
  52         base::TimeDelta::FromMilliseconds(kStartMillisecond));
  53     task_runner_ = new test::FakeSingleThreadTaskRunner(&testing_clock_);
  54     paced_sender_.reset(
  55         new PacedSender(&testing_clock_, &mock_transport_, task_runner_));
  56   }
  57
  58   virtual ~PacedSenderTest() {}
  59
  60   static void UpdateCastTransportStatus(transport::CastTransportStatus status) {
  61     NOTREACHED();
  62   }
  63
  64   PacketList CreatePacketList(size_t packet_size, int num_of_packets_in_frame) {
  65     PacketList packets;
  66     for (int i = 0; i < num_of_packets_in_frame; ++i) {
  67       packets.push_back(Packet(packet_size, kValue));
  68     }
  69     return packets;
  70   }
  71
  72   base::SimpleTestTickClock testing_clock_;
  73   TestPacketSender mock_transport_;
  74   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
  75   scoped_ptr<PacedSender> paced_sender_;
  76
  77   DISALLOW_COPY_AND_ASSIGN(PacedSenderTest);
  78 };
  79
  80 TEST_F(PacedSenderTest, PassThroughRtcp) {
  81   mock_transport_.AddExpectedSize(kSize1, 1);
  82   PacketList packets = CreatePacketList(kSize1, 1);
  83
  84   EXPECT_TRUE(paced_sender_->SendPackets(packets));
  85   EXPECT_TRUE(paced_sender_->ResendPackets(packets));
  86
  87   mock_transport_.AddExpectedSize(kSize2, 1);
  88   EXPECT_TRUE(paced_sender_->SendRtcpPacket(Packet(kSize2, kValue)));
  89 }
  90
  91 TEST_F(PacedSenderTest, BasicPace) {
  92   int num_of_packets = 9;
  93   PacketList packets = CreatePacketList(kSize1, num_of_packets);
  94
  95   mock_transport_.AddExpectedSize(kSize1, 3);
  96   EXPECT_TRUE(paced_sender_->SendPackets(packets));
  97
  98   // Check that we get the next burst.
  99   mock_transport_.AddExpectedSize(kSize1, 3);
 100
 101   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10);
 102   testing_clock_.Advance(timeout);
 103   task_runner_->RunTasks();
 104
 105   // If we call process too early make sure we don't send any packets.
 106   timeout = base::TimeDelta::FromMilliseconds(5);
 107   testing_clock_.Advance(timeout);
 108   task_runner_->RunTasks();
 109
 110   // Check that we get the next burst.
 111   mock_transport_.AddExpectedSize(kSize1, 3);
 112   testing_clock_.Advance(timeout);
 113   task_runner_->RunTasks();
 114
 115   // Check that we don't get any more packets.
 116   testing_clock_.Advance(timeout);
 117   task_runner_->RunTasks();
 118 }
 119
 120 TEST_F(PacedSenderTest, PaceWithNack) {
 121   // Testing what happen when we get multiple NACK requests for a fully lost
 122   // frames just as we sent the first packets in a frame.
 123   int num_of_packets_in_frame = 9;
 124   int num_of_packets_in_nack = 9;
 125
 126   PacketList first_frame_packets =
 127       CreatePacketList(kSize1, num_of_packets_in_frame);
 128
 129   PacketList second_frame_packets =
 130       CreatePacketList(kSize2, num_of_packets_in_frame);
 131
 132   PacketList nack_packets = CreatePacketList(kNackSize, num_of_packets_in_nack);
 133
 134   // Check that the first burst of the frame go out on the wire.
 135   mock_transport_.AddExpectedSize(kSize1, 3);
 136   EXPECT_TRUE(paced_sender_->SendPackets(first_frame_packets));
 137
 138   // Add first NACK request.
 139   EXPECT_TRUE(paced_sender_->ResendPackets(nack_packets));
 140
 141   // Check that we get the first NACK burst.
 142   mock_transport_.AddExpectedSize(kNackSize, 5);
 143   base::TimeDelta timeout = base::TimeDelta::FromMilliseconds(10);
 144   testing_clock_.Advance(timeout);
 145   task_runner_->RunTasks();
 146
 147   // Add second NACK request.
 148   EXPECT_TRUE(paced_sender_->ResendPackets(nack_packets));
 149
 150   // Check that we get the next NACK burst.
 151   mock_transport_.AddExpectedSize(kNackSize, 7);
 152   testing_clock_.Advance(timeout);
 153   task_runner_->RunTasks();
 154
 155   // End of NACK plus a packet from the oldest frame.
 156   mock_transport_.AddExpectedSize(kNackSize, 6);
 157   mock_transport_.AddExpectedSize(kSize1, 1);
 158   testing_clock_.Advance(timeout);
 159   task_runner_->RunTasks();
 160
 161   // Add second frame.
 162   // Make sure we don't delay the second frame due to the previous packets.
 163   EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets));
 164
 165   // Last packets of frame 1 and the first packets of frame 2.
 166   mock_transport_.AddExpectedSize(kSize1, 5);
 167   mock_transport_.AddExpectedSize(kSize2, 2);
 168   testing_clock_.Advance(timeout);
 169   task_runner_->RunTasks();
 170
 171   // Last packets of frame 2.
 172   mock_transport_.AddExpectedSize(kSize2, 7);
 173   testing_clock_.Advance(timeout);
 174   task_runner_->RunTasks();
 175
 176   // No more packets.
 177   testing_clock_.Advance(timeout);
 178   task_runner_->RunTasks();
 179 }
 180
 181 TEST_F(PacedSenderTest, PaceWith60fps) {
 182   // Testing what happen when we get multiple NACK requests for a fully lost
 183   // frames just as we sent the first packets in a frame.
 184   int num_of_packets_in_frame = 9;
 185
 186   PacketList first_frame_packets =
 187       CreatePacketList(kSize1, num_of_packets_in_frame);
 188
 189   PacketList second_frame_packets =
 190       CreatePacketList(kSize2, num_of_packets_in_frame);
 191
 192   PacketList third_frame_packets =
 193       CreatePacketList(kSize3, num_of_packets_in_frame);
 194
 195   PacketList fourth_frame_packets =
 196       CreatePacketList(kSize4, num_of_packets_in_frame);
 197
 198   base::TimeDelta timeout_10ms = base::TimeDelta::FromMilliseconds(10);
 199
 200   // Check that the first burst of the frame go out on the wire.
 201   mock_transport_.AddExpectedSize(kSize1, 3);
 202   EXPECT_TRUE(paced_sender_->SendPackets(first_frame_packets));
 203
 204   mock_transport_.AddExpectedSize(kSize1, 3);
 205   testing_clock_.Advance(timeout_10ms);
 206   task_runner_->RunTasks();
 207
 208   testing_clock_.Advance(base::TimeDelta::FromMilliseconds(6));
 209
 210   // Add second frame, after 16 ms.
 211   EXPECT_TRUE(paced_sender_->SendPackets(second_frame_packets));
 212   testing_clock_.Advance(base::TimeDelta::FromMilliseconds(4));
 213
 214   mock_transport_.AddExpectedSize(kSize1, 3);
 215   mock_transport_.AddExpectedSize(kSize2, 1);
 216   testing_clock_.Advance(timeout_10ms);
 217   task_runner_->RunTasks();
 218
 219   mock_transport_.AddExpectedSize(kSize2, 4);
 220   testing_clock_.Advance(timeout_10ms);
 221   task_runner_->RunTasks();
 222
 223   testing_clock_.Advance(base::TimeDelta::FromMilliseconds(3));
 224
 225   // Add third frame, after 33 ms.
 226   EXPECT_TRUE(paced_sender_->SendPackets(third_frame_packets));
 227   mock_transport_.AddExpectedSize(kSize2, 4);
 228   mock_transport_.AddExpectedSize(kSize3, 1);
 229
 230   testing_clock_.Advance(base::TimeDelta::FromMilliseconds(7));
 231   task_runner_->RunTasks();
 232
 233   // Add fourth frame, after 50 ms.
 234   EXPECT_TRUE(paced_sender_->SendPackets(fourth_frame_packets));
 235
 236   mock_transport_.AddExpectedSize(kSize3, 6);
 237   testing_clock_.Advance(timeout_10ms);
 238   task_runner_->RunTasks();
 239
 240   mock_transport_.AddExpectedSize(kSize3, 2);
 241   mock_transport_.AddExpectedSize(kSize4, 4);
 242   testing_clock_.Advance(timeout_10ms);
 243   task_runner_->RunTasks();
 244
 245   mock_transport_.AddExpectedSize(kSize4, 5);
 246   testing_clock_.Advance(timeout_10ms);
 247   task_runner_->RunTasks();
 248
 249   testing_clock_.Advance(timeout_10ms);
 250   task_runner_->RunTasks();
 251 }
 252
 253 }  // namespace transport
 254 }  // namespace cast
 255 }  // namespace media