blob: 638ca461c3caab8543b8e94261727dfc6383b911 [file] [log] [blame]
// Copyright (c) 2012 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 "net/quic/quic_connection_helper.h"
#include "net/quic/test_tools/mock_clock.h"
#include "net/quic/test_tools/mock_random.h"
#include "net/quic/test_tools/test_task_runner.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace net {
namespace test {
namespace {
class TestDelegate : public QuicAlarm::Delegate {
public:
TestDelegate() : fired_(false) {}
virtual QuicTime OnAlarm() OVERRIDE {
fired_ = true;
return QuicTime::Zero();
}
bool fired() const { return fired_; }
void Clear() { fired_= false; }
private:
bool fired_;
};
class QuicConnectionHelperTest : public ::testing::Test {
protected:
QuicConnectionHelperTest()
: runner_(new TestTaskRunner(&clock_)),
helper_(runner_.get(), &clock_, &random_generator_) {
}
scoped_refptr<TestTaskRunner> runner_;
QuicConnectionHelper helper_;
MockClock clock_;
MockRandom random_generator_;
};
TEST_F(QuicConnectionHelperTest, GetClock) {
EXPECT_EQ(&clock_, helper_.GetClock());
}
TEST_F(QuicConnectionHelperTest, GetRandomGenerator) {
EXPECT_EQ(&random_generator_, helper_.GetRandomGenerator());
}
TEST_F(QuicConnectionHelperTest, CreateAlarm) {
TestDelegate* delegate = new TestDelegate();
scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
alarm->Set(clock_.Now().Add(delta));
// Verify that the alarm task has been posted.
ASSERT_EQ(1u, runner_->GetPostedTasks().size());
EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()),
runner_->GetPostedTasks()[0].delay);
runner_->RunNextTask();
EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now());
EXPECT_TRUE(delegate->fired());
}
TEST_F(QuicConnectionHelperTest, CreateAlarmAndCancel) {
TestDelegate* delegate = new TestDelegate();
scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
alarm->Set(clock_.Now().Add(delta));
alarm->Cancel();
// The alarm task should still be posted.
ASSERT_EQ(1u, runner_->GetPostedTasks().size());
EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()),
runner_->GetPostedTasks()[0].delay);
runner_->RunNextTask();
EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now());
EXPECT_FALSE(delegate->fired());
}
TEST_F(QuicConnectionHelperTest, CreateAlarmAndReset) {
TestDelegate* delegate = new TestDelegate();
scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
alarm->Set(clock_.Now().Add(delta));
alarm->Cancel();
QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(3);
alarm->Set(clock_.Now().Add(new_delta));
// The alarm task should still be posted.
ASSERT_EQ(1u, runner_->GetPostedTasks().size());
EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()),
runner_->GetPostedTasks()[0].delay);
runner_->RunNextTask();
EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now());
EXPECT_FALSE(delegate->fired());
// The alarm task should be posted again.
ASSERT_EQ(1u, runner_->GetPostedTasks().size());
runner_->RunNextTask();
EXPECT_EQ(QuicTime::Zero().Add(new_delta), clock_.Now());
EXPECT_TRUE(delegate->fired());
}
TEST_F(QuicConnectionHelperTest, CreateAlarmAndResetEarlier) {
TestDelegate* delegate = new TestDelegate();
scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(3);
alarm->Set(clock_.Now().Add(delta));
alarm->Cancel();
QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(1);
alarm->Set(clock_.Now().Add(new_delta));
// Both alarm tasks will be posted.
ASSERT_EQ(2u, runner_->GetPostedTasks().size());
// The earlier task will execute and will fire the alarm->
runner_->RunNextTask();
EXPECT_EQ(QuicTime::Zero().Add(new_delta), clock_.Now());
EXPECT_TRUE(delegate->fired());
delegate->Clear();
// The latter task is still posted.
ASSERT_EQ(1u, runner_->GetPostedTasks().size());
// When the latter task is executed, the weak ptr will be invalid and
// the alarm will not fire.
runner_->RunNextTask();
EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now());
EXPECT_FALSE(delegate->fired());
}
TEST_F(QuicConnectionHelperTest, CreateAlarmAndUpdate) {
TestDelegate* delegate = new TestDelegate();
scoped_ptr<QuicAlarm> alarm(helper_.CreateAlarm(delegate));
const QuicClock* clock = helper_.GetClock();
QuicTime start = clock->Now();
QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
alarm->Set(clock->Now().Add(delta));
QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(3);
alarm->Update(clock->Now().Add(new_delta),
QuicTime::Delta::FromMicroseconds(1));
// The alarm task should still be posted.
ASSERT_EQ(1u, runner_->GetPostedTasks().size());
EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()),
runner_->GetPostedTasks()[0].delay);
runner_->RunNextTask();
EXPECT_EQ(QuicTime::Zero().Add(delta), clock->Now());
EXPECT_FALSE(delegate->fired());
// Move the alarm forward 1us and ensure it doesn't move forward.
alarm->Update(clock->Now().Add(new_delta),
QuicTime::Delta::FromMicroseconds(2));
ASSERT_EQ(1u, runner_->GetPostedTasks().size());
EXPECT_EQ(
base::TimeDelta::FromMicroseconds(
new_delta.Subtract(delta).ToMicroseconds()),
runner_->GetPostedTasks()[0].delay);
runner_->RunNextTask();
EXPECT_EQ(start.Add(new_delta), clock->Now());
EXPECT_TRUE(delegate->fired());
// Set the alarm via an update call.
new_delta = QuicTime::Delta::FromMicroseconds(5);
alarm->Update(clock->Now().Add(new_delta),
QuicTime::Delta::FromMicroseconds(1));
EXPECT_TRUE(alarm->IsSet());
// Update it with an uninitialized time and ensure it's cancelled.
alarm->Update(QuicTime::Zero(), QuicTime::Delta::FromMicroseconds(1));
EXPECT_FALSE(alarm->IsSet());
}
} // namespace
} // namespace test
} // namespace net