net/tools/quic/quic_epoll_connection_helper_test.cc

   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 #include "net/tools/quic/quic_epoll_connection_helper.h"
   6
   7 #include "net/quic/crypto/quic_random.h"
   8 #include "net/tools/quic/test_tools/mock_epoll_server.h"
   9 #include "testing/gtest/include/gtest/gtest.h"
  10
  11 using net::tools::test::MockEpollServer;
  12
  13 namespace net {
  14 namespace tools {
  15 namespace test {
  16 namespace {
  17
  18 class TestDelegate : public QuicAlarm::Delegate {
  19  public:
  20   TestDelegate() : fired_(false) {}
  21
  22   QuicTime OnAlarm() override {
  23     fired_ = true;
  24     return QuicTime::Zero();
  25   }
  26
  27   bool fired() const { return fired_; }
  28
  29  private:
  30   bool fired_;
  31 };
  32
  33 class QuicEpollConnectionHelperTest : public ::testing::Test {
  34  protected:
  35   QuicEpollConnectionHelperTest() : helper_(&epoll_server_) {}
  36
  37   MockEpollServer epoll_server_;
  38   QuicEpollConnectionHelper helper_;
  39 };
  40
  41 TEST_F(QuicEpollConnectionHelperTest, GetClock) {
  42   const QuicClock* clock = helper_.GetClock();
  43   QuicTime start = clock->Now();
  44
  45   QuicTime::Delta delta = QuicTime::Delta::FromMilliseconds(5);
  46   epoll_server_.AdvanceBy(delta.ToMicroseconds());
  47
  48   EXPECT_EQ(start.Add(delta), clock->Now());
  49 }
  50
  51 TEST_F(QuicEpollConnectionHelperTest, GetRandomGenerator) {
  52   QuicRandom* random = helper_.GetRandomGenerator();
  53   EXPECT_EQ(QuicRandom::GetInstance(), random);
  54 }
  55
  56 TEST_F(QuicEpollConnectionHelperTest, CreateAlarm) {
  57   TestDelegate* delegate = new TestDelegate();
  58   scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
  59
  60   const QuicClock* clock = helper_.GetClock();
  61   QuicTime start = clock->Now();
  62   QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
  63   alarm->Set(start.Add(delta));
  64
  65   epoll_server_.AdvanceByAndWaitForEventsAndExecuteCallbacks(
  66       delta.ToMicroseconds());
  67   EXPECT_EQ(start.Add(delta), clock->Now());
  68 }
  69
  70 TEST_F(QuicEpollConnectionHelperTest, CreateAlarmAndCancel) {
  71   TestDelegate* delegate = new TestDelegate();
  72   scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
  73
  74   const QuicClock* clock = helper_.GetClock();
  75   QuicTime start = clock->Now();
  76   QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
  77   alarm->Set(start.Add(delta));
  78   alarm->Cancel();
  79
  80   epoll_server_.AdvanceByExactlyAndCallCallbacks(delta.ToMicroseconds());
  81   EXPECT_EQ(start.Add(delta), clock->Now());
  82   EXPECT_FALSE(delegate->fired());
  83 }
  84
  85 TEST_F(QuicEpollConnectionHelperTest, CreateAlarmAndReset) {
  86   TestDelegate* delegate = new TestDelegate();
  87   scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
  88
  89   const QuicClock* clock = helper_.GetClock();
  90   QuicTime start = clock->Now();
  91   QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
  92   alarm->Set(clock->Now().Add(delta));
  93   alarm->Cancel();
  94   QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(3);
  95   alarm->Set(clock->Now().Add(new_delta));
  96
  97   epoll_server_.AdvanceByExactlyAndCallCallbacks(delta.ToMicroseconds());
  98   EXPECT_EQ(start.Add(delta), clock->Now());
  99   EXPECT_FALSE(delegate->fired());
 100
 101   epoll_server_.AdvanceByExactlyAndCallCallbacks(
 102       new_delta.Subtract(delta).ToMicroseconds());
 103   EXPECT_EQ(start.Add(new_delta), clock->Now());
 104   EXPECT_TRUE(delegate->fired());
 105 }
 106
 107 TEST_F(QuicEpollConnectionHelperTest, CreateAlarmAndUpdate) {
 108   TestDelegate* delegate = new TestDelegate();
 109   scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
 110
 111   const QuicClock* clock = helper_.GetClock();
 112   QuicTime start = clock->Now();
 113   QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
 114   alarm->Set(clock->Now().Add(delta));
 115   QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(3);
 116   alarm->Update(clock->Now().Add(new_delta),
 117                 QuicTime::Delta::FromMicroseconds(1));
 118
 119   epoll_server_.AdvanceByExactlyAndCallCallbacks(delta.ToMicroseconds());
 120   EXPECT_EQ(start.Add(delta), clock->Now());
 121   EXPECT_FALSE(delegate->fired());
 122
 123   // Move the alarm forward 1us and ensure it doesn't move forward.
 124   alarm->Update(clock->Now().Add(new_delta),
 125                 QuicTime::Delta::FromMicroseconds(2));
 126
 127   epoll_server_.AdvanceByExactlyAndCallCallbacks(
 128       new_delta.Subtract(delta).ToMicroseconds());
 129   EXPECT_EQ(start.Add(new_delta), clock->Now());
 130   EXPECT_TRUE(delegate->fired());
 131
 132   // Set the alarm via an update call.
 133   new_delta = QuicTime::Delta::FromMicroseconds(5);
 134   alarm->Update(clock->Now().Add(new_delta),
 135                 QuicTime::Delta::FromMicroseconds(1));
 136   EXPECT_TRUE(alarm->IsSet());
 137
 138   // Update it with an uninitialized time and ensure it's cancelled.
 139   alarm->Update(QuicTime::Zero(), QuicTime::Delta::FromMicroseconds(1));
 140   EXPECT_FALSE(alarm->IsSet());
 141 }
 142
 143 }  // namespace
 144 }  // namespace test
 145 }  // namespace tools
 146 }  // namespace net