1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 // Test for FixRate sender and receiver.
6
7 #include "base/logging.h"
8 #include "base/memory/scoped_ptr.h"
9 #include "net/quic/congestion_control/fix_rate_receiver.h"
10 #include "net/quic/congestion_control/fix_rate_sender.h"
11 #include "net/quic/quic_protocol.h"
12 #include "net/quic/test_tools/mock_clock.h"
13 #include "testing/gmock/include/gmock/gmock.h"
14 #include "testing/gtest/include/gtest/gtest.h"
15
16 namespace net {
17 namespace test {
18
19 class FixRateReceiverPeer : public FixRateReceiver {
20 public:
FixRateReceiverPeer()21 FixRateReceiverPeer()
22 : FixRateReceiver() {
23 }
SetBitrate(QuicBandwidth fix_rate)24 void SetBitrate(QuicBandwidth fix_rate) {
25 FixRateReceiver::configured_rate_ = fix_rate;
26 }
27 };
28
29 class FixRateTest : public ::testing::Test {
30 protected:
FixRateTest()31 FixRateTest()
32 : rtt_(QuicTime::Delta::FromMilliseconds(30)),
33 sender_(new FixRateSender(&clock_)),
34 receiver_(new FixRateReceiverPeer()),
35 start_(clock_.Now()) {
36 // Make sure clock does not start at 0.
37 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2));
38 }
39 const QuicTime::Delta rtt_;
40 MockClock clock_;
41 SendAlgorithmInterface::SentPacketsMap unused_packet_map_;
42 scoped_ptr<FixRateSender> sender_;
43 scoped_ptr<FixRateReceiverPeer> receiver_;
44 const QuicTime start_;
45 };
46
TEST_F(FixRateTest,ReceiverAPI)47 TEST_F(FixRateTest, ReceiverAPI) {
48 QuicCongestionFeedbackFrame feedback;
49 QuicTime timestamp(QuicTime::Zero());
50 receiver_->SetBitrate(QuicBandwidth::FromKBytesPerSecond(300));
51 receiver_->RecordIncomingPacket(1, 1, timestamp, false);
52 ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
53 EXPECT_EQ(kFixRate, feedback.type);
54 EXPECT_EQ(300000u, feedback.fix_rate.bitrate.ToBytesPerSecond());
55 }
56
TEST_F(FixRateTest,SenderAPI)57 TEST_F(FixRateTest, SenderAPI) {
58 QuicCongestionFeedbackFrame feedback;
59 feedback.type = kFixRate;
60 feedback.fix_rate.bitrate = QuicBandwidth::FromKBytesPerSecond(300);
61 sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now(),
62 unused_packet_map_);
63 EXPECT_EQ(300000, sender_->BandwidthEstimate().ToBytesPerSecond());
64 EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
65 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
66 sender_->OnPacketSent(clock_.Now(), 1, kDefaultMaxPacketSize,
67 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
68 EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
69 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
70 sender_->OnPacketSent(clock_.Now(), 2, kDefaultMaxPacketSize,
71 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
72 sender_->OnPacketSent(clock_.Now(), 3, 600, NOT_RETRANSMISSION,
73 HAS_RETRANSMITTABLE_DATA);
74 EXPECT_EQ(QuicTime::Delta::FromMilliseconds(10),
75 sender_->TimeUntilSend(clock_.Now(),
76 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
77 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(2));
78 EXPECT_EQ(QuicTime::Delta::Infinite(), sender_->TimeUntilSend(clock_.Now(),
79 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE));
80 clock_.AdvanceTime(QuicTime::Delta::FromMilliseconds(8));
81 sender_->OnPacketAcked(1, kDefaultMaxPacketSize, rtt_);
82 sender_->OnPacketAcked(2, kDefaultMaxPacketSize, rtt_);
83 sender_->OnPacketAcked(3, 600, rtt_);
84 EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
85 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE).IsZero());
86 }
87
TEST_F(FixRateTest,FixRatePacing)88 TEST_F(FixRateTest, FixRatePacing) {
89 const QuicByteCount packet_size = 1200;
90 const QuicBandwidth bitrate = QuicBandwidth::FromKBytesPerSecond(240);
91 const int64 num_packets = 200;
92 QuicCongestionFeedbackFrame feedback;
93 receiver_->SetBitrate(QuicBandwidth::FromKBytesPerSecond(240));
94 ASSERT_TRUE(receiver_->GenerateCongestionFeedback(&feedback));
95 sender_->OnIncomingQuicCongestionFeedbackFrame(feedback, clock_.Now(),
96 unused_packet_map_);
97 QuicTime acc_advance_time(QuicTime::Zero());
98 QuicPacketSequenceNumber sequence_number = 0;
99 for (int i = 0; i < num_packets; i += 2) {
100 EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
101 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
102 NOT_HANDSHAKE).IsZero());
103 sender_->OnPacketSent(clock_.Now(), sequence_number++, packet_size,
104 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
105 EXPECT_TRUE(sender_->TimeUntilSend(clock_.Now(),
106 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA,
107 NOT_HANDSHAKE).IsZero());
108 sender_->OnPacketSent(clock_.Now(), sequence_number++, packet_size,
109 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA);
110 QuicTime::Delta advance_time = sender_->TimeUntilSend(clock_.Now(),
111 NOT_RETRANSMISSION, HAS_RETRANSMITTABLE_DATA, NOT_HANDSHAKE);
112 clock_.AdvanceTime(advance_time);
113 sender_->OnPacketAcked(sequence_number - 1, packet_size, rtt_);
114 sender_->OnPacketAcked(sequence_number - 2, packet_size, rtt_);
115 acc_advance_time = acc_advance_time.Add(advance_time);
116 }
117 EXPECT_EQ(num_packets * packet_size * 1000000 / bitrate.ToBytesPerSecond(),
118 static_cast<uint64>(acc_advance_time.Subtract(start_)
119 .ToMicroseconds()));
120 }
121
122 } // namespace test
123 } // namespace net
124