src/net/quic/congestion_control/quic_send_scheduler_test.cc

// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "base/logging.h"
#include "base/memory/scoped_ptr.h"
#include "net/quic/congestion_control/quic_receipt_metrics_collector.h"
#include "net/quic/congestion_control/quic_send_scheduler.h"
#include "net/quic/test_tools/mock_clock.h"
#include "net/quic/quic_protocol.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"

namespace net {
namespace testing {

class QuicSendSchedulerTest : public ::testing::Test {
 protected:
  void SetUpCongestionType(CongestionFeedbackType congestion_type) {
    sender_.reset(new QuicSendScheduler(&clock_, congestion_type));
  }
  MockClock clock_;
  scoped_ptr<QuicSendScheduler> sender_;
};

TEST_F(QuicSendSchedulerTest, FixedRateSenderAPI) {
  SetUpCongestionType(kFixRate);
  QuicCongestionFeedbackFrame congestion_feedback;
  congestion_feedback.type = kFixRate;
  congestion_feedback.fix_rate.bitrate_in_bytes_per_second = 30000;
  sender_->OnIncomingQuicCongestionFeedbackFrame(congestion_feedback);
  EXPECT_EQ(-1, sender_->PeakSustainedBandwidth());
  EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
  EXPECT_EQ(kMaxPacketSize, sender_->AvailableCongestionWindow());
  sender_->SentPacket(1, kMaxPacketSize, false);
  EXPECT_EQ(QuicTime::Delta::FromMilliseconds(40),
            sender_->TimeUntilSend(false));
  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(35));
  EXPECT_EQ(QuicTime::Delta::Infinite(),
            sender_->TimeUntilSend(false));
  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(5));
  EXPECT_EQ(QuicTime::Delta::Infinite(),
            sender_->TimeUntilSend(false));
}

TEST_F(QuicSendSchedulerTest, FixedRatePacing) {
  SetUpCongestionType(kFixRate);
  QuicAckFrame ack;
  ack.received_info.largest_received = 0;
  sender_->OnIncomingAckFrame(ack);

  QuicCongestionFeedbackFrame feedback;
  feedback.type = kFixRate;
  feedback.fix_rate.bitrate_in_bytes_per_second = 100000;
  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback);

  QuicTime acc_advance_time;
  for (int i = 1; i <= 100; ++i) {
    EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
    EXPECT_EQ(kMaxPacketSize, sender_->AvailableCongestionWindow());
    sender_->SentPacket(i, kMaxPacketSize, false);
    QuicTime::Delta advance_time = sender_->TimeUntilSend(false);
    clock_.AdvanceTime(advance_time);
    acc_advance_time = acc_advance_time.Add(advance_time);
    // Ack the packet we sent.
    ack.received_info.RecordReceived(i);
    sender_->OnIncomingAckFrame(ack);
  }
  EXPECT_EQ(QuicTime::FromMilliseconds(1200), acc_advance_time);
}

TEST_F(QuicSendSchedulerTest, AvailableCongestionWindow) {
  SetUpCongestionType(kFixRate);
  QuicAckFrame ack;
  sender_->OnIncomingAckFrame(ack);

  QuicCongestionFeedbackFrame feedback;
  feedback.type = kFixRate;
  feedback.fix_rate.bitrate_in_bytes_per_second = 100000;
  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback);

  EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
  EXPECT_EQ(kMaxPacketSize, sender_->AvailableCongestionWindow());
  const int32 num_packets = 12;
  for (int i = 1; i <= num_packets; i++) {
    EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
    sender_->SentPacket(i, 100, false);
    EXPECT_EQ(kMaxPacketSize - (i * 100), sender_->AvailableCongestionWindow());
  }
  // Ack the packets we sent.
  for (int i = 1; i <= num_packets; i++) {
    ack.received_info.RecordReceived(i);
  }
  sender_->OnIncomingAckFrame(ack);
  EXPECT_EQ(kMaxPacketSize, sender_->AvailableCongestionWindow());
}

TEST_F(QuicSendSchedulerTest, FixedRateBandwidth) {
  SetUpCongestionType(kFixRate);
  QuicAckFrame ack;
  sender_->OnIncomingAckFrame(ack);

  QuicCongestionFeedbackFrame feedback;
  feedback.type = kFixRate;
  feedback.fix_rate.bitrate_in_bytes_per_second = 100000;
  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback);

  for (int i = 1; i <= 100; ++i) {
    QuicTime::Delta advance_time = sender_->TimeUntilSend(false);
    clock_.AdvanceTime(advance_time);
    EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
    EXPECT_EQ(kMaxPacketSize, sender_->AvailableCongestionWindow());
    sender_->SentPacket(i, 1000, false);
    // Ack the packet we sent.
    ack.received_info.RecordReceived(i);
    sender_->OnIncomingAckFrame(ack);
  }
  EXPECT_EQ(100000, sender_->BandwidthEstimate());
  EXPECT_EQ(101010, sender_->PeakSustainedBandwidth());
  EXPECT_EQ(101010, sender_->SentBandwidth());
}

TEST_F(QuicSendSchedulerTest, BandwidthWith3SecondGap) {
  SetUpCongestionType(kFixRate);
  QuicAckFrame ack;
  sender_->OnIncomingAckFrame(ack);

  QuicCongestionFeedbackFrame feedback;
  feedback.type = kFixRate;
  feedback.fix_rate.bitrate_in_bytes_per_second = 100000;
  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback);

  for (int i = 1; i <= 100; ++i) {
    clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
    EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
    EXPECT_EQ(kMaxPacketSize, sender_->AvailableCongestionWindow());
    sender_->SentPacket(i, 1000, false);
    // Ack the packet we sent.
    ack.received_info.RecordReceived(i);
    sender_->OnIncomingAckFrame(ack);
  }
  EXPECT_EQ(100000, sender_->BandwidthEstimate());
  EXPECT_EQ(100000, sender_->PeakSustainedBandwidth());
  EXPECT_EQ(100000, sender_->SentBandwidth());
  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(1000));
  EXPECT_EQ(50000, sender_->SentBandwidth());
  clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2100));
  EXPECT_EQ(100000, sender_->BandwidthEstimate());
  EXPECT_EQ(100000, sender_->PeakSustainedBandwidth());
  EXPECT_EQ(0, sender_->SentBandwidth());
  for (int i = 1; i <= 150; ++i) {
    EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
    EXPECT_EQ(kMaxPacketSize, sender_->AvailableCongestionWindow());
    sender_->SentPacket(i + 100, 1000, false);
    clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(10));
    // Ack the packet we sent.
    ack.received_info.RecordReceived(i + 100);
    sender_->OnIncomingAckFrame(ack);
  }
  EXPECT_EQ(100000, sender_->BandwidthEstimate());
  EXPECT_EQ(100000, sender_->PeakSustainedBandwidth());
  EXPECT_EQ(50000, sender_->SentBandwidth());
}

TEST_F(QuicSendSchedulerTest, Pacing) {
  SetUpCongestionType(kFixRate);
  QuicAckFrame ack;
  ack.received_info.largest_received = 0;
  sender_->OnIncomingAckFrame(ack);

  QuicCongestionFeedbackFrame feedback;
  feedback.type = kFixRate;
  // Test a high bitrate (8Mbit/s) to trigger pacing.
  feedback.fix_rate.bitrate_in_bytes_per_second = 1000000;
  sender_->OnIncomingQuicCongestionFeedbackFrame(feedback);

  QuicTime acc_advance_time;
  for (int i = 1; i <= 100;) {
    EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
    EXPECT_EQ(kMaxPacketSize * 2, sender_->AvailableCongestionWindow());
    sender_->SentPacket(i++, kMaxPacketSize, false);
    EXPECT_TRUE(sender_->TimeUntilSend(false).IsZero());
    sender_->SentPacket(i++, kMaxPacketSize, false);
    QuicTime::Delta advance_time = sender_->TimeUntilSend(false);
    clock_.AdvanceTime(advance_time);
    acc_advance_time = acc_advance_time.Add(advance_time);
    // Ack the packets we sent.
    ack.received_info.RecordReceived(i - 2);
    sender_->OnIncomingAckFrame(ack);
    ack.received_info.RecordReceived(i - 1);
    sender_->OnIncomingAckFrame(ack);
  }
  EXPECT_EQ(QuicTime::FromMilliseconds(120), acc_advance_time);
}

}  // namespace testing
}  // namespace net