media/cast/sender/congestion_control_unittest.cc

   1 // Copyright 2014 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 <stdint.h>
   6
   7 #include "base/bind.h"
   8 #include "base/test/simple_test_tick_clock.h"
   9 #include "media/cast/cast_defines.h"
  10 #include "media/cast/sender/congestion_control.h"
  11 #include "media/cast/test/fake_single_thread_task_runner.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace media {
  15 namespace cast {
  16
  17 static const uint32 kMaxBitrateConfigured = 5000000;
  18 static const uint32 kMinBitrateConfigured = 500000;
  19 static const int64 kStartMillisecond = INT64_C(12345678900000);
  20 static const double kTargetEmptyBufferFraction = 0.9;
  21
  22 class CongestionControlTest : public ::testing::Test {
  23  protected:
  24   CongestionControlTest()
  25       : task_runner_(new test::FakeSingleThreadTaskRunner(&testing_clock_)) {
  26     testing_clock_.Advance(
  27         base::TimeDelta::FromMilliseconds(kStartMillisecond));
  28     congestion_control_.reset(new CongestionControl(
  29         &testing_clock_, kMaxBitrateConfigured, kMinBitrateConfigured, 10));
  30   }
  31
  32   void AckFrame(uint32 frame_id) {
  33     congestion_control_->AckFrame(frame_id, testing_clock_.NowTicks());
  34   }
  35
  36   void Run(uint32 frames,
  37            size_t frame_size,
  38            base::TimeDelta rtt,
  39            base::TimeDelta frame_delay,
  40            base::TimeDelta ack_time) {
  41     for (frame_id_ = 0; frame_id_ < frames; frame_id_++) {
  42       congestion_control_->UpdateRtt(rtt);
  43       congestion_control_->SendFrameToTransport(
  44           frame_id_, frame_size, testing_clock_.NowTicks());
  45       task_runner_->PostDelayedTask(FROM_HERE,
  46                                     base::Bind(&CongestionControlTest::AckFrame,
  47                                                base::Unretained(this),
  48                                                frame_id_),
  49                                     ack_time);
  50       task_runner_->Sleep(frame_delay);
  51     }
  52   }
  53
  54   base::SimpleTestTickClock testing_clock_;
  55   scoped_ptr<CongestionControl> congestion_control_;
  56   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
  57   uint32 frame_id_;
  58
  59   DISALLOW_COPY_AND_ASSIGN(CongestionControlTest);
  60 };
  61
  62 TEST_F(CongestionControlTest, SimpleRun) {
  63   uint32 frame_delay = 33;
  64   uint32 frame_size = 10000 * 8;
  65   Run(500,
  66       frame_size,
  67       base::TimeDelta::FromMilliseconds(10),
  68       base::TimeDelta::FromMilliseconds(frame_delay),
  69       base::TimeDelta::FromMilliseconds(45));
  70   // Empty the buffer.
  71   task_runner_->Sleep(base::TimeDelta::FromMilliseconds(100));
  72
  73   uint32 safe_bitrate = frame_size * 1000 / frame_delay;
  74   uint32 bitrate = congestion_control_->GetBitrate(
  75       testing_clock_.NowTicks() + base::TimeDelta::FromMilliseconds(300),
  76       base::TimeDelta::FromMilliseconds(300));
  77   EXPECT_NEAR(
  78       safe_bitrate / kTargetEmptyBufferFraction, bitrate, safe_bitrate * 0.05);
  79
  80   bitrate = congestion_control_->GetBitrate(
  81       testing_clock_.NowTicks() + base::TimeDelta::FromMilliseconds(200),
  82       base::TimeDelta::FromMilliseconds(300));
  83   EXPECT_NEAR(safe_bitrate / kTargetEmptyBufferFraction * 2 / 3,
  84               bitrate,
  85               safe_bitrate * 0.05);
  86
  87   bitrate = congestion_control_->GetBitrate(
  88       testing_clock_.NowTicks() + base::TimeDelta::FromMilliseconds(100),
  89       base::TimeDelta::FromMilliseconds(300));
  90   EXPECT_NEAR(safe_bitrate / kTargetEmptyBufferFraction * 1 / 3,
  91               bitrate,
  92               safe_bitrate * 0.05);
  93
  94   // Add a large (100ms) frame.
  95   congestion_control_->SendFrameToTransport(
  96       frame_id_++, safe_bitrate * 100 / 1000, testing_clock_.NowTicks());
  97
  98   // Results should show that we have ~200ms to send
  99   bitrate = congestion_control_->GetBitrate(
 100       testing_clock_.NowTicks() + base::TimeDelta::FromMilliseconds(300),
 101       base::TimeDelta::FromMilliseconds(300));
 102   EXPECT_NEAR(safe_bitrate / kTargetEmptyBufferFraction * 2 / 3,
 103               bitrate,
 104               safe_bitrate * 0.05);
 105
 106   // Add another large (100ms) frame.
 107   congestion_control_->SendFrameToTransport(
 108       frame_id_++, safe_bitrate * 100 / 1000, testing_clock_.NowTicks());
 109
 110   // Resulst should show that we have ~100ms to send
 111   bitrate = congestion_control_->GetBitrate(
 112       testing_clock_.NowTicks() + base::TimeDelta::FromMilliseconds(300),
 113       base::TimeDelta::FromMilliseconds(300));
 114   EXPECT_NEAR(safe_bitrate / kTargetEmptyBufferFraction * 1 / 3,
 115               bitrate,
 116               safe_bitrate * 0.05);
 117 }
 118
 119
 120 }  // namespace cast
 121 }  // namespace media