Home | History | Annotate | Download | only in congestion_control 
      1 // Copyright (c) 2013 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 #include "base/basictypes.h"
      6 #include "base/logging.h"
      7 #include "base/memory/scoped_ptr.h"
      8 #include "net/quic/congestion_control/inter_arrival_state_machine.h"
      9 #include "net/quic/test_tools/mock_clock.h"
     10 #include "testing/gtest/include/gtest/gtest.h"
     11 
     12 namespace net {
     13 namespace test {
     14 
     15 class InterArrivalStateMachineTest : public ::testing::Test {
     16  protected:
     17   InterArrivalStateMachineTest() {
     18   }
     19 
     20   virtual void SetUp() {
     21     state_machine_.reset(new InterArrivalStateMachine(&clock_));
     22   }
     23 
     24   MockClock clock_;
     25   scoped_ptr<InterArrivalStateMachine> state_machine_;
     26 };
     27 
     28 TEST_F(InterArrivalStateMachineTest, SimplePacketLoss) {
     29   QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(100);
     30   state_machine_->set_rtt(rtt);
     31   state_machine_->IncreaseBitrateDecision();
     32 
     33   clock_.AdvanceTime(rtt);
     34   state_machine_->PacketLossEvent();
     35   state_machine_->DecreaseBitrateDecision();
     36   EXPECT_EQ(kInterArrivalStateStable,
     37             state_machine_->GetInterArrivalState());
     38 
     39   // Make sure we switch to state packet loss.
     40   clock_.AdvanceTime(rtt);
     41   state_machine_->PacketLossEvent();
     42   state_machine_->DecreaseBitrateDecision();
     43   EXPECT_EQ(kInterArrivalStatePacketLoss,
     44             state_machine_->GetInterArrivalState());
     45 
     46   // Make sure we stay in state packet loss.
     47   clock_.AdvanceTime(rtt);
     48   state_machine_->PacketLossEvent();
     49   state_machine_->DecreaseBitrateDecision();
     50   EXPECT_EQ(kInterArrivalStatePacketLoss,
     51             state_machine_->GetInterArrivalState());
     52 
     53   clock_.AdvanceTime(rtt);
     54   state_machine_->PacketLossEvent();
     55   state_machine_->DecreaseBitrateDecision();
     56   EXPECT_EQ(kInterArrivalStatePacketLoss,
     57             state_machine_->GetInterArrivalState());
     58 }
     59 
     60 TEST_F(InterArrivalStateMachineTest, SimpleDelay) {
     61   QuicTime::Delta rtt = QuicTime::Delta::FromMilliseconds(100);
     62   state_machine_->set_rtt(rtt);
     63   state_machine_->IncreaseBitrateDecision();
     64 
     65   clock_.AdvanceTime(rtt);
     66   state_machine_->IncreasingDelayEvent();
     67   state_machine_->DecreaseBitrateDecision();
     68   EXPECT_EQ(kInterArrivalStateStable,
     69             state_machine_->GetInterArrivalState());
     70 
     71   // Make sure we switch to state delay.
     72   clock_.AdvanceTime(rtt);
     73   state_machine_->IncreasingDelayEvent();
     74   state_machine_->DecreaseBitrateDecision();
     75   EXPECT_EQ(kInterArrivalStateDelay,
     76             state_machine_->GetInterArrivalState());
     77 
     78   clock_.AdvanceTime(rtt);
     79   state_machine_->IncreasingDelayEvent();
     80   state_machine_->DecreaseBitrateDecision();
     81   EXPECT_EQ(kInterArrivalStateDelay,
     82             state_machine_->GetInterArrivalState());
     83 
     84   // Make sure we switch to state competing flow(s).
     85   clock_.AdvanceTime(rtt);
     86   state_machine_->IncreasingDelayEvent();
     87   state_machine_->DecreaseBitrateDecision();
     88   EXPECT_EQ(kInterArrivalStateCompetingFlow,
     89             state_machine_->GetInterArrivalState());
     90 
     91   // Make sure we stay in state competing flow(s).
     92   clock_.AdvanceTime(rtt);
     93   state_machine_->IncreasingDelayEvent();
     94   state_machine_->DecreaseBitrateDecision();
     95   EXPECT_EQ(kInterArrivalStateCompetingFlow,
     96             state_machine_->GetInterArrivalState());
     97 
     98   clock_.AdvanceTime(rtt);
     99   state_machine_->PacketLossEvent();
    100   state_machine_->DecreaseBitrateDecision();
    101   EXPECT_EQ(kInterArrivalStateCompetingFlow,
    102             state_machine_->GetInterArrivalState());
    103 
    104   clock_.AdvanceTime(rtt);
    105   state_machine_->PacketLossEvent();
    106   state_machine_->DecreaseBitrateDecision();
    107   EXPECT_EQ(kInterArrivalStateCompetingFlow,
    108             state_machine_->GetInterArrivalState());
    109 
    110   // Make sure we switch to state competing TCP flow(s).
    111   clock_.AdvanceTime(rtt);
    112   state_machine_->PacketLossEvent();
    113   state_machine_->DecreaseBitrateDecision();
    114   EXPECT_EQ(kInterArrivalStateCompetingTcpFLow,
    115             state_machine_->GetInterArrivalState());
    116 
    117   // Make sure we stay in state competing TCP flow(s).
    118   clock_.AdvanceTime(rtt);
    119   state_machine_->PacketLossEvent();
    120   state_machine_->DecreaseBitrateDecision();
    121   EXPECT_EQ(kInterArrivalStateCompetingTcpFLow,
    122             state_machine_->GetInterArrivalState());
    123 }
    124 
    125 }  // namespace test
    126 }  // namespace net
    127