| // Copyright (c) 2013 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 "base/logging.h" |
| #include "net/quic/congestion_control/channel_estimator.h" |
| #include "net/quic/test_tools/mock_clock.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace net { |
| namespace test { |
| |
| class ChannelEstimatorTest : public ::testing::Test { |
| protected: |
| virtual void SetUp() { |
| srand(1234); |
| packet_size_ = 1200; |
| sequence_number_ = 1; |
| } |
| |
| QuicPacketSequenceNumber sequence_number_; |
| QuicByteCount packet_size_; |
| MockClock send_clock_; |
| MockClock receive_clock_; |
| ChannelEstimator channel_estimator_; |
| }; |
| |
| TEST_F(ChannelEstimatorTest, SimpleNonDetect) { |
| // In this test, the send times differ by the same delta as the receive times, |
| // so we haven't sent packets closely enough to detect "spreading," or |
| // effective bandwidth. |
| QuicTime::Delta delta = QuicTime::Delta::FromMilliseconds(10); |
| |
| for (int i = 0; i < 1000; ++i) { |
| QuicTime send_time = send_clock_.ApproximateNow(); |
| QuicTime receive_time = receive_clock_.ApproximateNow(); |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| send_clock_.AdvanceTime(delta); |
| receive_clock_.AdvanceTime(delta); |
| } |
| QuicBandwidth estimate = QuicBandwidth::Zero(); |
| EXPECT_EQ(kChannelEstimateUnknown, |
| channel_estimator_.GetChannelEstimate(&estimate)); |
| EXPECT_TRUE(estimate.IsZero()); |
| } |
| |
| TEST_F(ChannelEstimatorTest, SimplePacketPairDetect) { |
| // In this test, we start by sending packet pairs back-to-back and |
| // add a receive side spreading that indicate an effective bandwidth. |
| // We do 2 testes with different effective bandwidth to make sure that we |
| // detect the new effective bandwidth. |
| QuicTime::Delta received_delta = QuicTime::Delta::FromMilliseconds(5); |
| QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10); |
| |
| for (int i = 0; i < 100; ++i) { |
| receive_clock_.AdvanceTime(received_delta); |
| QuicTime receive_time = receive_clock_.ApproximateNow(); |
| QuicTime send_time = send_clock_.ApproximateNow(); |
| |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| receive_clock_.AdvanceTime(received_delta); |
| receive_time = receive_clock_.ApproximateNow(); |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| send_clock_.AdvanceTime(send_delta); |
| } |
| QuicBandwidth estimate = QuicBandwidth::Zero(); |
| EXPECT_EQ(kChannelEstimateGood, |
| channel_estimator_.GetChannelEstimate(&estimate)); |
| EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, received_delta), |
| estimate); |
| received_delta = QuicTime::Delta::FromMilliseconds(1); |
| for (int i = 0; i < 100; ++i) { |
| receive_clock_.AdvanceTime(received_delta); |
| QuicTime receive_time = receive_clock_.ApproximateNow(); |
| QuicTime send_time = send_clock_.ApproximateNow(); |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| receive_clock_.AdvanceTime(received_delta); |
| receive_time = receive_clock_.ApproximateNow(); |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| send_clock_.AdvanceTime(send_delta); |
| } |
| EXPECT_EQ(kChannelEstimateGood, |
| channel_estimator_.GetChannelEstimate(&estimate)); |
| EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, received_delta), |
| estimate); |
| } |
| |
| TEST_F(ChannelEstimatorTest, SimpleFlatSlope) { |
| // In this test, we send packet pairs back-to-back and add a slowly increasing |
| // receive side spreading. We expect the estimate to be good and that our |
| // mean receive side spreading is returned as the estimate. |
| QuicTime::Delta initial_received_delta = QuicTime::Delta::FromMilliseconds(5); |
| QuicTime::Delta received_delta = initial_received_delta; |
| QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10); |
| |
| for (int i = 0; i < 100; ++i) { |
| receive_clock_.AdvanceTime(received_delta); |
| QuicTime receive_time = receive_clock_.ApproximateNow(); |
| QuicTime send_time = send_clock_.ApproximateNow(); |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| receive_clock_.AdvanceTime(received_delta); |
| receive_time = receive_clock_.ApproximateNow(); |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| send_clock_.AdvanceTime(send_delta); |
| received_delta = received_delta.Add(QuicTime::Delta::FromMicroseconds(10)); |
| } |
| QuicBandwidth estimate = QuicBandwidth::Zero(); |
| EXPECT_EQ(kChannelEstimateGood, |
| channel_estimator_.GetChannelEstimate(&estimate)); |
| |
| // Calculate our mean receive delta. |
| QuicTime::Delta increased_received_delta = |
| received_delta.Subtract(initial_received_delta); |
| QuicTime::Delta mean_received_delta = initial_received_delta.Add( |
| QuicTime::Delta::FromMicroseconds( |
| increased_received_delta.ToMicroseconds() / 2)); |
| |
| EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, |
| mean_received_delta), estimate); |
| } |
| |
| TEST_F(ChannelEstimatorTest, SimpleMediumSlope) { |
| // In this test, we send packet pairs back-to-back and add an increasing |
| // receive side spreading. We expect the estimate to be uncertaint and that |
| // our mean receive side spreading is returned as the estimate. |
| QuicTime::Delta initial_received_delta = QuicTime::Delta::FromMilliseconds(5); |
| QuicTime::Delta received_delta = initial_received_delta; |
| QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10); |
| |
| for (int i = 0; i < 100; ++i) { |
| receive_clock_.AdvanceTime(received_delta); |
| QuicTime receive_time = receive_clock_.ApproximateNow(); |
| QuicTime send_time = send_clock_.ApproximateNow(); |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| receive_clock_.AdvanceTime(received_delta); |
| receive_time = receive_clock_.ApproximateNow(); |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| send_clock_.AdvanceTime(send_delta); |
| received_delta = received_delta.Add(QuicTime::Delta::FromMicroseconds(50)); |
| } |
| QuicBandwidth estimate = QuicBandwidth::Zero(); |
| EXPECT_EQ(kChannelEstimateUncertain, |
| channel_estimator_.GetChannelEstimate(&estimate)); |
| |
| // Calculate our mean receive delta. |
| QuicTime::Delta increased_received_delta = |
| received_delta.Subtract(initial_received_delta); |
| QuicTime::Delta mean_received_delta = initial_received_delta.Add( |
| QuicTime::Delta::FromMicroseconds( |
| increased_received_delta.ToMicroseconds() / 2)); |
| |
| EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, |
| mean_received_delta), estimate); |
| } |
| |
| TEST_F(ChannelEstimatorTest, SimpleSteepSlope) { |
| // In this test, we send packet pairs back-to-back and add a rapidly |
| // increasing receive side spreading. We expect the estimate to be uncertain |
| // and that our mean receive side spreading is returned as the estimate. |
| QuicTime::Delta initial_received_delta = QuicTime::Delta::FromMilliseconds(5); |
| QuicTime::Delta received_delta = initial_received_delta; |
| QuicTime::Delta send_delta = QuicTime::Delta::FromMilliseconds(10); |
| |
| for (int i = 0; i < 100; ++i) { |
| receive_clock_.AdvanceTime(received_delta); |
| QuicTime receive_time = receive_clock_.ApproximateNow(); |
| QuicTime send_time = send_clock_.ApproximateNow(); |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| receive_clock_.AdvanceTime(received_delta); |
| receive_time = receive_clock_.ApproximateNow(); |
| channel_estimator_.OnAcknowledgedPacket(sequence_number_++, |
| packet_size_, |
| send_time, |
| receive_time); |
| send_clock_.AdvanceTime(send_delta); |
| received_delta = received_delta.Add(QuicTime::Delta::FromMicroseconds(100)); |
| } |
| QuicBandwidth estimate = QuicBandwidth::Zero(); |
| EXPECT_EQ(kChannelEstimateUncertain, |
| channel_estimator_.GetChannelEstimate(&estimate)); |
| |
| // Calculate our mean receive delta. |
| QuicTime::Delta increased_received_delta = |
| received_delta.Subtract(initial_received_delta); |
| QuicTime::Delta mean_received_delta = initial_received_delta.Add( |
| QuicTime::Delta::FromMicroseconds( |
| increased_received_delta.ToMicroseconds() / 2)); |
| |
| EXPECT_EQ(QuicBandwidth::FromBytesAndTimeDelta(packet_size_, |
| mean_received_delta), estimate); |
| } |
| |
| } // namespace test |
| } // namespace net |