Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(354)

Side by Side Diff: net/quic/quic_chromium_alarm_factory_test.cc

Issue 1901423003: Plumbs new SpdyFramerVisitorInterface method handling through QUIC test utilities, including the te… (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@119562680
Patch Set: Created 4 years, 8 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « net/net.gypi ('k') | net/quic/quic_client_session_base.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 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 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "net/quic/quic_chromium_connection_helper.h" 5 #include "net/quic/quic_chromium_alarm_factory.h"
Ryan Hamilton 2016/04/20 18:44:58 Is this supposed to be part of this CL?
6 6
7 #include "net/quic/test_tools/mock_clock.h" 7 #include "net/quic/test_tools/mock_clock.h"
8 #include "net/quic/test_tools/mock_random.h" 8 #include "net/quic/test_tools/mock_random.h"
9 #include "net/quic/test_tools/test_task_runner.h" 9 #include "net/quic/test_tools/test_task_runner.h"
10 #include "testing/gtest/include/gtest/gtest.h" 10 #include "testing/gtest/include/gtest/gtest.h"
11 11
12 namespace net { 12 namespace net {
13 namespace test { 13 namespace test {
14 namespace { 14 namespace {
15 15
16 class TestDelegate : public QuicAlarm::Delegate { 16 class TestDelegate : public QuicAlarm::Delegate {
17 public: 17 public:
18 TestDelegate() : fired_(false) {} 18 TestDelegate() : fired_(false) {}
19 19
20 void OnAlarm() override { fired_ = true; } 20 void OnAlarm() override { fired_ = true; }
21 21
22 bool fired() const { return fired_; } 22 bool fired() const { return fired_; }
23 void Clear() { fired_ = false; } 23 void Clear() { fired_ = false; }
24 24
25 private: 25 private:
26 bool fired_; 26 bool fired_;
27 }; 27 };
28 28
29 class QuicChromiumConnectionHelperTest : public ::testing::Test { 29 class QuicChromiumAlarmFactoryTest : public ::testing::Test {
30 protected: 30 protected:
31 QuicChromiumConnectionHelperTest() 31 QuicChromiumAlarmFactoryTest()
32 : runner_(new TestTaskRunner(&clock_)), 32 : runner_(new TestTaskRunner(&clock_)),
33 alarm_factory_(runner_.get(), &clock_, ) {} 33 alarm_factory_(runner_.get(), &clock_) {}
34 34
35 scoped_refptr<TestTaskRunner> runner_; 35 scoped_refptr<TestTaskRunner> runner_;
36 QuicChromiumAlarmFactory alarm_factory_; 36 QuicChromiumAlarmFactory alarm_factory_;
37 MockClock clock_; 37 MockClock clock_;
38 }; 38 };
39 39
40 TEST_F(QuicChromiumConnectionHelperTest, CreateAlarm) { 40 TEST_F(QuicChromiumAlarmFactoryTest, CreateAlarm) {
41 TestDelegate* delegate = new TestDelegate(); 41 TestDelegate* delegate = new TestDelegate();
42 std::unique_ptr<QuicAlarm> alarm(alarm_factory_.CreateAlarm(delegate)); 42 std::unique_ptr<QuicAlarm> alarm(alarm_factory_.CreateAlarm(delegate));
43 43
44 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1); 44 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
45 alarm->Set(clock_.Now().Add(delta)); 45 alarm->Set(clock_.Now().Add(delta));
46 46
47 // Verify that the alarm task has been posted. 47 // Verify that the alarm task has been posted.
48 ASSERT_EQ(1u, runner_->GetPostedTasks().size()); 48 ASSERT_EQ(1u, runner_->GetPostedTasks().size());
49 EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()), 49 EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()),
50 runner_->GetPostedTasks()[0].delay); 50 runner_->GetPostedTasks()[0].delay);
51 51
52 runner_->RunNextTask(); 52 runner_->RunNextTask();
53 EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now()); 53 EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now());
54 EXPECT_TRUE(delegate->fired()); 54 EXPECT_TRUE(delegate->fired());
55 } 55 }
56 56
57 TEST_F(QuicChromiumConnectionHelperTest, CreateAlarmAndCancel) { 57 TEST_F(QuicChromiumAlarmFactoryTest, CreateAlarmAndCancel) {
58 TestDelegate* delegate = new TestDelegate(); 58 TestDelegate* delegate = new TestDelegate();
59 std::unique_ptr<QuicAlarm> alarm(alarm_factory_.CreateAlarm(delegate)); 59 std::unique_ptr<QuicAlarm> alarm(alarm_factory_.CreateAlarm(delegate));
60 60
61 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1); 61 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
62 alarm->Set(clock_.Now().Add(delta)); 62 alarm->Set(clock_.Now().Add(delta));
63 alarm->Cancel(); 63 alarm->Cancel();
64 64
65 // The alarm task should still be posted. 65 // The alarm task should still be posted.
66 ASSERT_EQ(1u, runner_->GetPostedTasks().size()); 66 ASSERT_EQ(1u, runner_->GetPostedTasks().size());
67 EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()), 67 EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()),
68 runner_->GetPostedTasks()[0].delay); 68 runner_->GetPostedTasks()[0].delay);
69 69
70 runner_->RunNextTask(); 70 runner_->RunNextTask();
71 EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now()); 71 EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now());
72 EXPECT_FALSE(delegate->fired()); 72 EXPECT_FALSE(delegate->fired());
73 } 73 }
74 74
75 TEST_F(QuicChromiumConnectionHelperTest, CreateAlarmAndReset) { 75 TEST_F(QuicChromiumAlarmFactoryTest, CreateAlarmAndReset) {
76 TestDelegate* delegate = new TestDelegate(); 76 TestDelegate* delegate = new TestDelegate();
77 std::unique_ptr<QuicAlarm> alarm(alarm_factory_.CreateAlarm(delegate)); 77 std::unique_ptr<QuicAlarm> alarm(alarm_factory_.CreateAlarm(delegate));
78 78
79 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1); 79 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
80 alarm->Set(clock_.Now().Add(delta)); 80 alarm->Set(clock_.Now().Add(delta));
81 alarm->Cancel(); 81 alarm->Cancel();
82 QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(3); 82 QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(3);
83 alarm->Set(clock_.Now().Add(new_delta)); 83 alarm->Set(clock_.Now().Add(new_delta));
84 84
85 // The alarm task should still be posted. 85 // The alarm task should still be posted.
86 ASSERT_EQ(1u, runner_->GetPostedTasks().size()); 86 ASSERT_EQ(1u, runner_->GetPostedTasks().size());
87 EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()), 87 EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()),
88 runner_->GetPostedTasks()[0].delay); 88 runner_->GetPostedTasks()[0].delay);
89 89
90 runner_->RunNextTask(); 90 runner_->RunNextTask();
91 EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now()); 91 EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now());
92 EXPECT_FALSE(delegate->fired()); 92 EXPECT_FALSE(delegate->fired());
93 93
94 // The alarm task should be posted again. 94 // The alarm task should be posted again.
95 ASSERT_EQ(1u, runner_->GetPostedTasks().size()); 95 ASSERT_EQ(1u, runner_->GetPostedTasks().size());
96 96
97 runner_->RunNextTask(); 97 runner_->RunNextTask();
98 EXPECT_EQ(QuicTime::Zero().Add(new_delta), clock_.Now()); 98 EXPECT_EQ(QuicTime::Zero().Add(new_delta), clock_.Now());
99 EXPECT_TRUE(delegate->fired()); 99 EXPECT_TRUE(delegate->fired());
100 } 100 }
101 101
102 TEST_F(QuicChromiumConnectionHelperTest, CreateAlarmAndResetEarlier) { 102 TEST_F(QuicChromiumAlarmFactoryTest, CreateAlarmAndResetEarlier) {
103 TestDelegate* delegate = new TestDelegate(); 103 TestDelegate* delegate = new TestDelegate();
104 std::unique_ptr<QuicAlarm> alarm(alarm_factory_.CreateAlarm(delegate)); 104 std::unique_ptr<QuicAlarm> alarm(alarm_factory_.CreateAlarm(delegate));
105 105
106 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(3); 106 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(3);
107 alarm->Set(clock_.Now().Add(delta)); 107 alarm->Set(clock_.Now().Add(delta));
108 alarm->Cancel(); 108 alarm->Cancel();
109 QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(1); 109 QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(1);
110 alarm->Set(clock_.Now().Add(new_delta)); 110 alarm->Set(clock_.Now().Add(new_delta));
111 111
112 // Both alarm tasks will be posted. 112 // Both alarm tasks will be posted.
113 ASSERT_EQ(2u, runner_->GetPostedTasks().size()); 113 ASSERT_EQ(2u, runner_->GetPostedTasks().size());
114 114
115 // The earlier task will execute and will fire the alarm-> 115 // The earlier task will execute and will fire the alarm->
116 runner_->RunNextTask(); 116 runner_->RunNextTask();
117 EXPECT_EQ(QuicTime::Zero().Add(new_delta), clock_.Now()); 117 EXPECT_EQ(QuicTime::Zero().Add(new_delta), clock_.Now());
118 EXPECT_TRUE(delegate->fired()); 118 EXPECT_TRUE(delegate->fired());
119 delegate->Clear(); 119 delegate->Clear();
120 120
121 // The latter task is still posted. 121 // The latter task is still posted.
122 ASSERT_EQ(1u, runner_->GetPostedTasks().size()); 122 ASSERT_EQ(1u, runner_->GetPostedTasks().size());
123 123
124 // When the latter task is executed, the weak ptr will be invalid and 124 // When the latter task is executed, the weak ptr will be invalid and
125 // the alarm will not fire. 125 // the alarm will not fire.
126 runner_->RunNextTask(); 126 runner_->RunNextTask();
127 EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now()); 127 EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now());
128 EXPECT_FALSE(delegate->fired()); 128 EXPECT_FALSE(delegate->fired());
129 } 129 }
130 130
131 TEST_F(QuicChromiumConnectionHelperTest, CreateAlarmAndUpdate) { 131 TEST_F(QuicChromiumAlarmFactoryTest, CreateAlarmAndUpdate) {
132 TestDelegate* delegate = new TestDelegate(); 132 TestDelegate* delegate = new TestDelegate();
133 std::unique_ptr<QuicAlarm> alarm(alarm_factory_.CreateAlarm(delegate)); 133 std::unique_ptr<QuicAlarm> alarm(alarm_factory_.CreateAlarm(delegate));
134 134
135 QuicTime start = clock_->Now(); 135 QuicTime start = clock_.Now();
136 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1); 136 QuicTime::Delta delta = QuicTime::Delta::FromMicroseconds(1);
137 alarm->Set(clock_->Now().Add(delta)); 137 alarm->Set(clock_.Now().Add(delta));
138 QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(3); 138 QuicTime::Delta new_delta = QuicTime::Delta::FromMicroseconds(3);
139 alarm->Update(clock_->Now().Add(new_delta), 139 alarm->Update(clock_.Now().Add(new_delta),
140 QuicTime::Delta::FromMicroseconds(1)); 140 QuicTime::Delta::FromMicroseconds(1));
141 141
142 // The alarm task should still be posted. 142 // The alarm task should still be posted.
143 ASSERT_EQ(1u, runner_->GetPostedTasks().size()); 143 ASSERT_EQ(1u, runner_->GetPostedTasks().size());
144 EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()), 144 EXPECT_EQ(base::TimeDelta::FromMicroseconds(delta.ToMicroseconds()),
145 runner_->GetPostedTasks()[0].delay); 145 runner_->GetPostedTasks()[0].delay);
146 146
147 runner_->RunNextTask(); 147 runner_->RunNextTask();
148 EXPECT_EQ(QuicTime::Zero().Add(delta), clock_->Now()); 148 EXPECT_EQ(QuicTime::Zero().Add(delta), clock_.Now());
149 EXPECT_FALSE(delegate->fired()); 149 EXPECT_FALSE(delegate->fired());
150 150
151 // Move the alarm forward 1us and ensure it doesn't move forward. 151 // Move the alarm forward 1us and ensure it doesn't move forward.
152 alarm->Update(clock_->Now().Add(new_delta), 152 alarm->Update(clock_.Now().Add(new_delta),
153 QuicTime::Delta::FromMicroseconds(2)); 153 QuicTime::Delta::FromMicroseconds(2));
154 154
155 ASSERT_EQ(1u, runner_->GetPostedTasks().size()); 155 ASSERT_EQ(1u, runner_->GetPostedTasks().size());
156 EXPECT_EQ(base::TimeDelta::FromMicroseconds( 156 EXPECT_EQ(base::TimeDelta::FromMicroseconds(
157 new_delta.Subtract(delta).ToMicroseconds()), 157 new_delta.Subtract(delta).ToMicroseconds()),
158 runner_->GetPostedTasks()[0].delay); 158 runner_->GetPostedTasks()[0].delay);
159 runner_->RunNextTask(); 159 runner_->RunNextTask();
160 EXPECT_EQ(start.Add(new_delta), clock_->Now()); 160 EXPECT_EQ(start.Add(new_delta), clock_.Now());
161 EXPECT_TRUE(delegate->fired()); 161 EXPECT_TRUE(delegate->fired());
162 162
163 // Set the alarm via an update call. 163 // Set the alarm via an update call.
164 new_delta = QuicTime::Delta::FromMicroseconds(5); 164 new_delta = QuicTime::Delta::FromMicroseconds(5);
165 alarm->Update(clock_->Now().Add(new_delta), 165 alarm->Update(clock_.Now().Add(new_delta),
166 QuicTime::Delta::FromMicroseconds(1)); 166 QuicTime::Delta::FromMicroseconds(1));
167 EXPECT_TRUE(alarm->IsSet()); 167 EXPECT_TRUE(alarm->IsSet());
168 168
169 // Update it with an uninitialized time and ensure it's cancelled. 169 // Update it with an uninitialized time and ensure it's cancelled.
170 alarm->Update(QuicTime::Zero(), QuicTime::Delta::FromMicroseconds(1)); 170 alarm->Update(QuicTime::Zero(), QuicTime::Delta::FromMicroseconds(1));
171 EXPECT_FALSE(alarm->IsSet()); 171 EXPECT_FALSE(alarm->IsSet());
172 } 172 }
173 173
174 } // namespace 174 } // namespace
175 } // namespace test 175 } // namespace test
176 } // namespace net 176 } // namespace net
OLDNEW
« no previous file with comments | « net/net.gypi ('k') | net/quic/quic_client_session_base.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698