src/net/quic/congestion_control/inter_arrival_state_machine_test.cc

   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