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

net/quic/congestion_control/tcp_cubic_sender_bytes_test.cc

 // Copyright (c) 2015 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_bytes.h"
 
 #include <algorithm>
 #include <cstdint>
 #include <memory>
 
 #include "base/logging.h"
 #include "net/quic/congestion_control/rtt_stats.h"
 #include "net/quic/crypto/crypto_protocol.h"
 #include "net/quic/proto/cached_network_parameters.pb.h"
 #include "net/quic/quic_flags.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/quic_utils.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 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 TcpCubicSenderBytesPeer : public TcpCubicSenderBytes {
  public:
   TcpCubicSenderBytesPeer(const QuicClock* clock, bool reno)
       : TcpCubicSenderBytes(clock,
                             &rtt_stats_,
                             reno,
                             kInitialCongestionWindowPackets,
-                            kMaxCongestionWindow,
+                            kMaxCongestionWindowPackets,
                             &stats_) {}
 
   const HybridSlowStart& hybrid_slow_start() const {
     return hybrid_slow_start_;
   }
 
   float GetRenoBeta() const { return RenoBeta(); }
 
   RttStats rtt_stats_;
   QuicConnectionStats stats_;
@@ skipping 673 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 * kDefaultTCPMSS, sender_->GetCongestionWindow());
 
   // 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 * kDefaultTCPMSS,
+  EXPECT_EQ(kMaxCongestionWindowPackets * kDefaultTCPMSS,
             sender_->GetCongestionWindow());
 
   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_->GetCongestionWindow());
   } else {
     cached_network_params.set_bandwidth_estimate_bytes_per_second(
         (kMinCongestionWindowForBandwidthResumption - 1) * kDefaultTCPMSS);
     sender_->ResumeConnectionState(cached_network_params, false);
     EXPECT_EQ(kMinCongestionWindowForBandwidthResumption * kDefaultTCPMSS,
               sender_->GetCongestionWindow());
   }
 
   // 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(TcpCubicSenderBytesTest, 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);
@@ skipping 30 matching lines @@
 
   // 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, sender_->GetSlowStartThreshold());
 
   // Resets cwnd and slow start threshold on connection migrations.
   sender_->OnConnectionMigration();
   EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
-  EXPECT_EQ(kMaxCongestionWindow * kDefaultTCPMSS,
+  EXPECT_EQ(kMaxCongestionWindowPackets * kDefaultTCPMSS,
             sender_->GetSlowStartThreshold());
   EXPECT_FALSE(sender_->hybrid_slow_start().started());
 }
 
 }  // namespace test
 }  // namespace net