Landing Recent QUIC changes until 5/14/2016 02:25:25 UTC

net/quic/congestion_control/tcp_cubic_sender_packets_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 "net/quic/congestion_control/tcp_cubic_sender_packets.h"
 
 #include <algorithm>
 #include <memory>
 
 #include "base/logging.h"
@@ skipping 10 matching lines @@
 
 using std::min;
 
 namespace net {
 namespace test {
 
 // TODO(ianswett): A number of theses tests were written with the assumption of
 // an initial CWND of 10. They have carefully calculated values which should be
 // updated to be based on kInitialCongestionWindow.
 const uint32_t kInitialCongestionWindowPackets = 10;
+const uint32_t kMaxCongestionWindowPackets = 200;
 const uint32_t kDefaultWindowTCP =
     kInitialCongestionWindowPackets * kDefaultTCPMSS;
 const float kRenoBeta = 0.7f;  // Reno backoff factor.
 
 class TcpCubicSenderPacketsPeer : public TcpCubicSenderPackets {
  public:
   TcpCubicSenderPacketsPeer(const QuicClock* clock,
                             bool reno,
                             QuicPacketCount max_tcp_congestion_window)
       : TcpCubicSenderPackets(clock,
@@ skipping 14 matching lines @@
   float GetRenoBeta() const { return RenoBeta(); }
 
   RttStats rtt_stats_;
   QuicConnectionStats stats_;
 };
 
 class TcpCubicSenderPacketsTest : public ::testing::Test {
  protected:
   TcpCubicSenderPacketsTest()
       : one_ms_(QuicTime::Delta::FromMilliseconds(1)),
-        sender_(
-            new TcpCubicSenderPacketsPeer(&clock_, true, kMaxCongestionWindow)),
+        sender_(new TcpCubicSenderPacketsPeer(&clock_,
+                                              true,
+                                              kMaxCongestionWindowPackets)),
         packet_number_(1),
         acked_packet_number_(0),
         bytes_in_flight_(0) {}
 
   int SendAvailableSendWindow() {
     return SendAvailableSendWindow(kDefaultTCPMSS);
   }
 
   int SendAvailableSendWindow(QuicPacketLength packet_length) {
     // Send as long as TimeUntilSend returns Zero.
@@ skipping 403 matching lines @@
 
   // Exit recovery and return to sending at the new rate.
   for (int i = 0; i < kNumberOfAcks; ++i) {
     AckNPackets(1);
     EXPECT_EQ(1, SendAvailableSendWindow());
   }
 }
 
 TEST_F(TcpCubicSenderPacketsTest, RTOCongestionWindow) {
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
-  EXPECT_EQ(kMaxCongestionWindow, sender_->slowstart_threshold());
+  EXPECT_EQ(kMaxCongestionWindowPackets, sender_->slowstart_threshold());
 
   // Expect the window to decrease to the minimum once the RTO fires
   // and slow start threshold to be set to 1/2 of the CWND.
   sender_->OnRetransmissionTimeout(true);
   EXPECT_EQ(2 * kDefaultTCPMSS, sender_->GetCongestionWindow());
   EXPECT_EQ(5u, sender_->slowstart_threshold());
 }
 
 TEST_F(TcpCubicSenderPacketsTest, RTOCongestionWindowNoRetransmission) {
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
@@ skipping 371 matching lines @@
   cached_network_params.set_min_rtt_ms(1000);
 
   // Make sure that a bandwidth estimate results in a changed CWND.
   cached_network_params.set_timestamp(clock_.WallNow().ToUNIXSeconds() -
                                       (kNumSecondsPerHour - 1));
   sender_->ResumeConnectionState(cached_network_params, false);
   EXPECT_EQ(kNumberOfPackets, sender_->congestion_window());
 
   // Resumed CWND is limited to be in a sensible range.
   cached_network_params.set_bandwidth_estimate_bytes_per_second(
-      (kMaxCongestionWindow + 1) * kDefaultTCPMSS);
+      (kMaxCongestionWindowPackets + 1) * kDefaultTCPMSS);
   sender_->ResumeConnectionState(cached_network_params, false);
-  EXPECT_EQ(kMaxCongestionWindow, sender_->congestion_window());
+  EXPECT_EQ(kMaxCongestionWindowPackets, sender_->congestion_window());
 
   if (FLAGS_quic_no_lower_bw_resumption_limit) {
     // Resume with an illegal value of 0 and verify the server uses 1 instead.
     cached_network_params.set_bandwidth_estimate_bytes_per_second(0);
     sender_->ResumeConnectionState(cached_network_params, false);
     EXPECT_EQ(sender_->min_congestion_window(), sender_->congestion_window());
   } else {
     cached_network_params.set_bandwidth_estimate_bytes_per_second(
         (kMinCongestionWindowForBandwidthResumption - 1) * kDefaultTCPMSS);
     sender_->ResumeConnectionState(cached_network_params, false);
     EXPECT_EQ(kMinCongestionWindowForBandwidthResumption,
               sender_->congestion_window());
   }
 
   // Resume to the max value.
   cached_network_params.set_max_bandwidth_estimate_bytes_per_second(
-      kMaxCongestionWindow * kDefaultTCPMSS);
+      kMaxCongestionWindowPackets * kDefaultTCPMSS);
   sender_->ResumeConnectionState(cached_network_params, true);
-  EXPECT_EQ(kMaxCongestionWindow * kDefaultTCPMSS,
+  EXPECT_EQ(kMaxCongestionWindowPackets * kDefaultTCPMSS,
             sender_->GetCongestionWindow());
 }
 
 TEST_F(TcpCubicSenderPacketsTest, PaceBelowCWND) {
   QuicConfig config;
 
   // Verify that kCOPT: kMIN4 forces the min CWND to 1 packet, but allows up
   // to 4 to be sent.
   QuicTagVector options;
   options.push_back(kMIN4);
   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
   sender_->SetFromConfig(config, Perspective::IS_SERVER);
   sender_->OnRetransmissionTimeout(true);
   EXPECT_EQ(1u, sender_->congestion_window());
   EXPECT_TRUE(
       sender_->TimeUntilSend(QuicTime::Zero(), kDefaultTCPMSS).IsZero());
   EXPECT_TRUE(
       sender_->TimeUntilSend(QuicTime::Zero(), 2 * kDefaultTCPMSS).IsZero());
   EXPECT_TRUE(
       sender_->TimeUntilSend(QuicTime::Zero(), 3 * kDefaultTCPMSS).IsZero());
   EXPECT_FALSE(
       sender_->TimeUntilSend(QuicTime::Zero(), 4 * kDefaultTCPMSS).IsZero());
 }
 
 TEST_F(TcpCubicSenderPacketsTest, ResetAfterConnectionMigration) {
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
-  EXPECT_EQ(kMaxCongestionWindow, sender_->slowstart_threshold());
+  EXPECT_EQ(kMaxCongestionWindowPackets, sender_->slowstart_threshold());
 
   // Starts with slow start.
   sender_->SetNumEmulatedConnections(1);
   const int kNumberOfAcks = 10;
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
   SendAvailableSendWindow();
   QuicByteCount expected_send_window =
       kDefaultWindowTCP + (kDefaultTCPMSS * 2 * kNumberOfAcks);
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 
   // Loses a packet to exit slow start.
   LoseNPackets(1);
 
   // We should now have fallen out of slow start with a reduced window. Slow
   // start threshold is also updated.
   expected_send_window *= kRenoBeta;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
   EXPECT_EQ(expected_send_window / kDefaultTCPMSS,
             sender_->slowstart_threshold());
 
   // Resets cwnd and slow start threshold on connection migrations.
   sender_->OnConnectionMigration();
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
-  EXPECT_EQ(kMaxCongestionWindow, sender_->slowstart_threshold());
+  EXPECT_EQ(kMaxCongestionWindowPackets, sender_->slowstart_threshold());
   EXPECT_FALSE(sender_->hybrid_slow_start().started());
 }
 
 }  // namespace test
 }  // namespace net