Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(234)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: net/quic/congestion_control/tcp_cubic_sender_test.cc

Issue 266243004: Clang format slam. Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Created 6 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« net/base/mime_util_unittest.cc ('K') | « net/quic/congestion_control/tcp_cubic_sender.cc ('k') | net/quic/congestion_control/tcp_loss_algorithm.cc » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: net/quic/congestion_control/tcp_cubic_sender_test.cc
diff --git a/net/quic/congestion_control/tcp_cubic_sender_test.cc b/net/quic/congestion_control/tcp_cubic_sender_test.cc
index e6e9e8bd383e964dfc4a215fecd7afcc14f226eb..83f97620ae3aef7f599a339c68ec14dd901c999c 100644
--- a/net/quic/congestion_control/tcp_cubic_sender_test.cc
+++ b/net/quic/congestion_control/tcp_cubic_sender_test.cc
@@ -29,13 +29,13 @@ class TcpCubicSenderPeer : public TcpCubicSender {
TcpCubicSenderPeer(const QuicClock* clock,
bool reno,
QuicTcpCongestionWindow max_tcp_congestion_window)
- : TcpCubicSender(
- clock, &rtt_stats_, reno, max_tcp_congestion_window, &stats_) {
- }
+ : TcpCubicSender(clock,
+ &rtt_stats_,
+ reno,
+ max_tcp_congestion_window,
+ &stats_) {}
- QuicTcpCongestionWindow congestion_window() {
- return congestion_window_;
- }
+ QuicTcpCongestionWindow congestion_window() { return congestion_window_; }
const HybridSlowStart& hybrid_slow_start() const {
return hybrid_slow_start_;
@@ -52,24 +52,26 @@ class TcpCubicSenderTest : public ::testing::Test {
protected:
TcpCubicSenderTest()
: one_ms_(QuicTime::Delta::FromMilliseconds(1)),
- sender_(new TcpCubicSenderPeer(&clock_, true,
+ sender_(new TcpCubicSenderPeer(&clock_,
+ true,
kDefaultMaxCongestionWindowTCP)),
receiver_(new TcpReceiver()),
sequence_number_(1),
- acked_sequence_number_(0) {
- }
+ acked_sequence_number_(0) {}
int SendAvailableSendWindow() {
// Send as long as TimeUntilSend returns Zero.
int packets_sent = 0;
- bool can_send = sender_->TimeUntilSend(
- clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero();
+ bool can_send =
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero();
while (can_send) {
- sender_->OnPacketSent(clock_.Now(), sequence_number_++, kDefaultTCPMSS,
+ sender_->OnPacketSent(clock_.Now(),
+ sequence_number_++,
+ kDefaultTCPMSS,
HAS_RETRANSMITTABLE_DATA);
++packets_sent;
- can_send = sender_->TimeUntilSend(
- clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero();
+ can_send = sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA)
+ .IsZero();
}
return packets_sent;
}
@@ -111,41 +113,41 @@ TEST_F(TcpCubicSenderTest, SimpleSender) {
EXPECT_EQ(kDefaultWindowTCP, sender_->AvailableSendWindow());
EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
// At startup make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Get default QuicCongestionFeedbackFrame from receiver.
ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
// Make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// And that window is un-affected.
EXPECT_EQ(kDefaultWindowTCP, sender_->AvailableSendWindow());
EXPECT_EQ(kDefaultWindowTCP, sender_->GetCongestionWindow());
// There is available window, so we should be able to send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Fill the send window with data, then verify that we can't send.
SendAvailableSendWindow();
- EXPECT_FALSE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_FALSE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
}
TEST_F(TcpCubicSenderTest, ExponentialSlowStart) {
const int kNumberOfAcks = 20;
QuicCongestionFeedbackFrame feedback;
// At startup make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Get default QuicCongestionFeedbackFrame from receiver.
ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
// Make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
for (int i = 0; i < kNumberOfAcks; ++i) {
// Send our full send window.
@@ -166,14 +168,14 @@ TEST_F(TcpCubicSenderTest, SlowStartAckTrain) {
const int kNumberOfAcks = 65;
QuicCongestionFeedbackFrame feedback;
// At startup make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Get default QuicCongestionFeedbackFrame from receiver.
ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
// Make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
for (int i = 0; i < kNumberOfAcks; ++i) {
// Send our full send window.
@@ -209,14 +211,14 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
// Make sure that we fall out of slow start when we encounter a packet loss.
QuicCongestionFeedbackFrame feedback;
// At startup make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Get default QuicCongestionFeedbackFrame from receiver.
ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
// Make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
const int kNumberOfAcks = 10;
for (int i = 0; i < kNumberOfAcks; ++i) {
@@ -225,16 +227,16 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLoss) {
AckNPackets(2);
}
SendAvailableSendWindow();
- QuicByteCount expected_send_window = kDefaultWindowTCP +
- (kDefaultTCPMSS * 2 * kNumberOfAcks);
+ QuicByteCount expected_send_window =
+ kDefaultWindowTCP + (kDefaultTCPMSS * 2 * kNumberOfAcks);
EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
sender_->OnPacketLost(acked_sequence_number_ + 1, clock_.Now());
++acked_sequence_number_;
// Make sure that we can send right now due to limited transmit.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// We should now have fallen out of slow start.
// We expect window to be cut in half by Reno.
@@ -277,8 +279,8 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLossPRR) {
// Make sure that we fall out of slow start when we encounter a packet loss.
QuicCongestionFeedbackFrame feedback;
// At startup make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Get default QuicCongestionFeedbackFrame from receiver.
ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
@@ -291,8 +293,8 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLossPRR) {
AckNPackets(2);
}
SendAvailableSendWindow();
- QuicByteCount expected_send_window = kDefaultWindowTCP +
- (kDefaultTCPMSS * 2 * kNumberOfAcks);
+ QuicByteCount expected_send_window =
+ kDefaultWindowTCP + (kDefaultTCPMSS * 2 * kNumberOfAcks);
EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
LoseNPackets(1);
@@ -303,8 +305,8 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLossPRR) {
EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
// Send 1 packet to simulate limited transmit.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
EXPECT_EQ(1, SendAvailableSendWindow());
// Testing TCP proportional rate reduction.
@@ -316,8 +318,8 @@ TEST_F(TcpCubicSenderTest, SlowStartPacketLossPRR) {
size_t remaining_packets_in_recovery = number_of_packets_in_window * 2 - 1;
for (size_t i = 0; i < remaining_packets_in_recovery - 1; i += 2) {
AckNPackets(2);
- EXPECT_TRUE(sender_->TimeUntilSend(
- clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA)
+ .IsZero());
EXPECT_EQ(0u, sender_->AvailableSendWindow());
EXPECT_EQ(1, SendAvailableSendWindow());
EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
@@ -346,8 +348,8 @@ TEST_F(TcpCubicSenderTest, SlowStartBurstPacketLossPRR) {
// Make sure that we fall out of slow start when we encounter a packet loss.
QuicCongestionFeedbackFrame feedback;
// At startup make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Get default QuicCongestionFeedbackFrame from receiver.
ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
@@ -360,8 +362,8 @@ TEST_F(TcpCubicSenderTest, SlowStartBurstPacketLossPRR) {
AckNPackets(2);
}
SendAvailableSendWindow();
- QuicByteCount expected_send_window = kDefaultWindowTCP +
- (kDefaultTCPMSS * 2 * kNumberOfAcks);
+ QuicByteCount expected_send_window =
+ kDefaultWindowTCP + (kDefaultTCPMSS * 2 * kNumberOfAcks);
EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
// Ack a packet with a 15 packet gap, losing 13 of them due to FACK.
@@ -448,10 +450,10 @@ TEST_F(TcpCubicSenderTest, RetransmissionDelay) {
EXPECT_NEAR(expected_delay.ToMilliseconds(),
sender_->RetransmissionDelay().ToMilliseconds(),
1);
- EXPECT_EQ(static_cast<int64>(
- sender_->GetCongestionWindow() * kNumMicrosPerSecond /
- sender_->rtt_stats_.SmoothedRtt().ToMicroseconds()),
- sender_->BandwidthEstimate().ToBytesPerSecond());
+ EXPECT_EQ(
+ static_cast<int64>(sender_->GetCongestionWindow() * kNumMicrosPerSecond /
+ sender_->rtt_stats_.SmoothedRtt().ToMicroseconds()),
+ sender_->BandwidthEstimate().ToBytesPerSecond());
}
TEST_F(TcpCubicSenderTest, SlowStartMaxSendWindow) {
@@ -462,42 +464,39 @@ TEST_F(TcpCubicSenderTest, SlowStartMaxSendWindow) {
QuicCongestionFeedbackFrame feedback;
// At startup make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Get default QuicCongestionFeedbackFrame from receiver.
ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
// Make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
for (int i = 0; i < kNumberOfAcks; ++i) {
// Send our full send window.
SendAvailableSendWindow();
AckNPackets(2);
}
- QuicByteCount expected_send_window =
- kMaxCongestionWindowTCP * kDefaultTCPMSS;
+ QuicByteCount expected_send_window = kMaxCongestionWindowTCP * kDefaultTCPMSS;
EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
}
TEST_F(TcpCubicSenderTest, TcpRenoMaxCongestionWindow) {
const QuicTcpCongestionWindow kMaxCongestionWindowTCP = 50;
const int kNumberOfAcks = 1000;
- sender_.reset(
- new TcpCubicSenderPeer(&clock_, true, kMaxCongestionWindowTCP));
+ sender_.reset(new TcpCubicSenderPeer(&clock_, true, kMaxCongestionWindowTCP));
QuicCongestionFeedbackFrame feedback;
// At startup make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Get default QuicCongestionFeedbackFrame from receiver.
ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
// Make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
-
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
SendAvailableSendWindow();
AckNPackets(2);
@@ -510,8 +509,7 @@ TEST_F(TcpCubicSenderTest, TcpRenoMaxCongestionWindow) {
AckNPackets(2);
}
- QuicByteCount expected_send_window =
- kMaxCongestionWindowTCP * kDefaultTCPMSS;
+ QuicByteCount expected_send_window = kMaxCongestionWindowTCP * kDefaultTCPMSS;
EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
}
@@ -525,14 +523,14 @@ TEST_F(TcpCubicSenderTest, TcpCubicMaxCongestionWindow) {
QuicCongestionFeedbackFrame feedback;
// At startup make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Get default QuicCongestionFeedbackFrame from receiver.
ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
// Make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
SendAvailableSendWindow();
AckNPackets(2);
@@ -545,8 +543,7 @@ TEST_F(TcpCubicSenderTest, TcpCubicMaxCongestionWindow) {
AckNPackets(2);
}
- QuicByteCount expected_send_window =
- kMaxCongestionWindowTCP * kDefaultTCPMSS;
+ QuicByteCount expected_send_window = kMaxCongestionWindowTCP * kDefaultTCPMSS;
EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
}
@@ -572,13 +569,17 @@ TEST_F(TcpCubicSenderTest, SendWindowNotAffectedByAcks) {
// Send a packet with no retransmittable data, and ensure that the congestion
// window doesn't change.
QuicByteCount bytes_in_packet = min(kDefaultTCPMSS, send_window);
- sender_->OnPacketSent(clock_.Now(), sequence_number_++, bytes_in_packet,
+ sender_->OnPacketSent(clock_.Now(),
+ sequence_number_++,
+ bytes_in_packet,
NO_RETRANSMITTABLE_DATA);
EXPECT_EQ(send_window, sender_->AvailableSendWindow());
// Send a data packet with retransmittable data, and ensure that the
// congestion window has shrunk.
- sender_->OnPacketSent(clock_.Now(), sequence_number_++, bytes_in_packet,
+ sender_->OnPacketSent(clock_.Now(),
+ sequence_number_++,
+ bytes_in_packet,
HAS_RETRANSMITTABLE_DATA);
EXPECT_GT(send_window, sender_->AvailableSendWindow());
}
@@ -596,8 +597,8 @@ TEST_F(TcpCubicSenderTest, CongestionAvoidanceAtEndOfRecovery) {
// Make sure that we fall out of slow start when we encounter a packet loss.
QuicCongestionFeedbackFrame feedback;
// At startup make sure we can send.
- EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
- HAS_RETRANSMITTABLE_DATA).IsZero());
+ EXPECT_TRUE(
+ sender_->TimeUntilSend(clock_.Now(), HAS_RETRANSMITTABLE_DATA).IsZero());
// Get default QuicCongestionFeedbackFrame from receiver.
ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now());
@@ -609,8 +610,8 @@ TEST_F(TcpCubicSenderTest, CongestionAvoidanceAtEndOfRecovery) {
AckNPackets(2);
}
SendAvailableSendWindow();
- QuicByteCount expected_send_window = kDefaultWindowTCP +
- (kDefaultTCPMSS * 2 * kNumberOfAcks);
+ QuicByteCount expected_send_window =
+ kDefaultWindowTCP + (kDefaultTCPMSS * 2 * kNumberOfAcks);
EXPECT_EQ(expected_send_window, sender_->GetCongestionWindow());
LoseNPackets(1);
« net/base/mime_util_unittest.cc ('K') | « net/quic/congestion_control/tcp_cubic_sender.cc ('k') | net/quic/congestion_control/tcp_loss_algorithm.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698