Allow the number of connections QUIC's send algorithms simulate to

net/quic/congestion_control/tcp_cubic_sender_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 <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/quic/congestion_control/rtt_stats.h"
 #include "net/quic/congestion_control/tcp_cubic_sender.h"
@@ skipping 183 matching lines @@
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
   QuicByteCount bytes_to_send = sender_->SendWindow();
   EXPECT_EQ(kDefaultWindowTCP + kDefaultTCPMSS * 2 * kNumberOfAcks,
             bytes_to_send);
 }
 
 TEST_F(TcpCubicSenderTest, SlowStartAckTrain) {
+  sender_->SetNumEmulatedConnections(1);
   EXPECT_EQ(kDefaultMaxCongestionWindowTCP * kDefaultTCPMSS,
             sender_->GetSlowStartThreshold());
 
   // Make sure that we fall out of slow start when we send ACK train longer
   // than half the RTT, in this test case 30ms, which is more than 30 calls to
   // Ack2Packets in one round.
   // Since we start at 10 packet first round will be 5 second round 10 etc
   // Hence we should pass 30 at 65 = 5 + 10 + 20 + 30
   const int kNumberOfAcks = 65;
   for (int i = 0; i < kNumberOfAcks; ++i) {
@@ skipping 30 matching lines @@
   EXPECT_EQ(expected_send_window / 2 / kDefaultTCPMSS,
             sender_->slowstart_threshold());
 
   // Now revert the RTO and ensure the CWND and slowstart threshold revert.
   sender_->RevertRetransmissionTimeout();
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
   EXPECT_EQ(140u, sender_->slowstart_threshold());
 }
 
 TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
+  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());
@@ skipping 43 matching lines @@
   // PRR will allow 2 packets for every ack during recovery.
   EXPECT_EQ(2, SendAvailableSendWindow());
   // Simulate abandoning all packets by supplying a bytes_in_flight of 0.
   // PRR should now allow a packet to be sent, even though prr's state
   // variables believe it has sent enough packets.
   EXPECT_EQ(QuicTime::Delta::Zero(),
             sender_->TimeUntilSend(clock_.Now(), 0, HAS_RETRANSMITTABLE_DATA));
 }
 
 TEST_F(TcpCubicSenderTest, SlowStartPacketLossPRR) {
+  sender_->SetNumEmulatedConnections(1);
   // Test based on the first example in RFC6937.
   // Ack 10 packets in 5 acks to raise the CWND to 20, as in the example.
   const int kNumberOfAcks = 5;
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
   SendAvailableSendWindow();
   QuicByteCount expected_send_window = kDefaultWindowTCP +
@@ skipping 28 matching lines @@
     EXPECT_EQ(1, SendAvailableSendWindow());
     EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
   }
 
   AckNPackets(1);
   expected_send_window += kDefaultTCPMSS;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 }
 
 TEST_F(TcpCubicSenderTest, SlowStartBurstPacketLossPRR) {
+  sender_->SetNumEmulatedConnections(1);
   // Test based on the second example in RFC6937, though we also implement
   // forward acknowledgements, so the first two incoming acks will trigger
   // PRR immediately.
   // Ack 10 packets in 5 acks to raise the CWND to 20, as in the example.
   const int kNumberOfAcks = 5;
   for (int i = 0; i < kNumberOfAcks; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
   }
@@ skipping 209 matching lines @@
 
   // Verify that kCOPT: kIW10 forces the congestion window to the
   // default of 10 regardless of ReceivedInitialWindow.
   QuicTagVector options;
   options.push_back(kIW10);
   QuicConfigPeer::SetReceivedConnectionOptions(&config, options);
   sender_->SetFromConfig(config, true);
   EXPECT_EQ(congestion_window, sender_->congestion_window());
 }
 
-TEST_F(TcpCubicSenderTest, CongestionAvoidanceAtEndOfRecovery) {
+TEST_F(TcpCubicSenderTest, 2ConnectionCongestionAvoidanceAtEndOfRecovery) {
+  sender_->SetNumEmulatedConnections(2);
   // Ack 10 packets in 5 acks to raise the CWND to 20.
   const int kNumberOfAcks = 5;
   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());
+
+  LoseNPackets(1);
+
+  // We should now have fallen out of slow start, and window should be cut in
+  // half by Reno. New cwnd should be 10.
+  expected_send_window /= 2;
+  EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+
+  // No congestion window growth should occur in recovery phase, i.e., until the
+  // currently outstanding 20 packets are acked.
+  for (int i = 0; i < 10; ++i) {
+    // Send our full send window.
+    SendAvailableSendWindow();
+    EXPECT_TRUE(sender_->InRecovery());
+    AckNPackets(2);
+    EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+  }
+  EXPECT_FALSE(sender_->InRecovery());
+
+  // Out of recovery now. Congestion window should not grow for half an RTT.
+  SendAvailableSendWindow();
+  AckNPackets(2);
+  EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+
+  // Next ack will be the 5th and should increase congestion window by 1MSS.
+  AckNPackets(2);
+  expected_send_window += kDefaultTCPMSS;
+  EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+
+  for (int i = 0; i < 2; ++i) {
+    SendAvailableSendWindow();
+    AckNPackets(2);
+    EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+  }
+
+  // Next ack should cause congestion window to grow by 1MSS.
+  AckNPackets(2);
+  expected_send_window += kDefaultTCPMSS;
+  EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
+}
+
+TEST_F(TcpCubicSenderTest, 1ConnectionCongestionAvoidanceAtEndOfRecovery) {
+  sender_->SetNumEmulatedConnections(1);
+  // Ack 10 packets in 5 acks to raise the CWND to 20.
+  const int kNumberOfAcks = 5;
+  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());
 
   LoseNPackets(1);
 
   // We should now have fallen out of slow start, and window should be cut in
   // half by Reno. New cwnd should be 10.
   expected_send_window /= 2;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 
   // No congestion window growth should occur in recovery phase, i.e.,
   // until the currently outstanding 20 packets are acked.
   for (int i = 0; i < 10; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
+    EXPECT_TRUE(sender_->InRecovery());
     AckNPackets(2);
     EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
   }
+  EXPECT_FALSE(sender_->InRecovery());
 
   // Out of recovery now. Congestion window should not grow during RTT.
   for (int i = 0; i < 4; ++i) {
     // Send our full send window.
     SendAvailableSendWindow();
     AckNPackets(2);
     EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
   }
 
   // Next ack should cause congestion window to grow by 1MSS.
   AckNPackets(2);
   expected_send_window += kDefaultTCPMSS;
   EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
 }
 
 }  // namespace test
 }  // namespace net