OLD | NEW |
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_protocol.h" | 5 #include "net/quic/quic_protocol.h" |
6 | 6 |
7 #include <sstream> | 7 #include <sstream> |
8 | 8 |
9 #include "base/stl_util.h" | 9 #include "base/stl_util.h" |
10 #include "net/quic/quic_flags.h" | 10 #include "net/quic/quic_flags.h" |
(...skipping 63 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
74 | 74 |
75 // TODO(rtenneti): Enable checking of Log(ERROR) messages. | 75 // TODO(rtenneti): Enable checking of Log(ERROR) messages. |
76 #if 0 | 76 #if 0 |
77 // Any logs would indicate an unsupported version which we don't expect. | 77 // Any logs would indicate an unsupported version which we don't expect. |
78 ScopedMockLog log(kDoNotCaptureLogsYet); | 78 ScopedMockLog log(kDoNotCaptureLogsYet); |
79 EXPECT_CALL(log, Log(_, _, _)).Times(0); | 79 EXPECT_CALL(log, Log(_, _, _)).Times(0); |
80 log.StartCapturingLogs(); | 80 log.StartCapturingLogs(); |
81 #endif | 81 #endif |
82 | 82 |
83 // Explicitly test a specific version. | 83 // Explicitly test a specific version. |
84 EXPECT_EQ(MakeQuicTag('Q', '0', '2', '5'), | 84 EXPECT_EQ(MakeQuicTag('Q', '0', '3', '0'), |
85 QuicVersionToQuicTag(QUIC_VERSION_25)); | 85 QuicVersionToQuicTag(QUIC_VERSION_30)); |
86 | 86 |
87 // Loop over all supported versions and make sure that we never hit the | 87 // Loop over all supported versions and make sure that we never hit the |
88 // default case (i.e. all supported versions should be successfully converted | 88 // default case (i.e. all supported versions should be successfully converted |
89 // to valid QuicTags). | 89 // to valid QuicTags). |
90 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { | 90 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { |
91 QuicVersion version = kSupportedQuicVersions[i]; | 91 QuicVersion version = kSupportedQuicVersions[i]; |
92 EXPECT_LT(0u, QuicVersionToQuicTag(version)); | 92 EXPECT_LT(0u, QuicVersionToQuicTag(version)); |
93 } | 93 } |
94 } | 94 } |
95 | 95 |
(...skipping 18 matching lines...) Expand all Loading... |
114 | 114 |
115 // TODO(rtenneti): Enable checking of Log(ERROR) messages. | 115 // TODO(rtenneti): Enable checking of Log(ERROR) messages. |
116 #if 0 | 116 #if 0 |
117 // Any logs would indicate an unsupported version which we don't expect. | 117 // Any logs would indicate an unsupported version which we don't expect. |
118 ScopedMockLog log(kDoNotCaptureLogsYet); | 118 ScopedMockLog log(kDoNotCaptureLogsYet); |
119 EXPECT_CALL(log, Log(_, _, _)).Times(0); | 119 EXPECT_CALL(log, Log(_, _, _)).Times(0); |
120 log.StartCapturingLogs(); | 120 log.StartCapturingLogs(); |
121 #endif | 121 #endif |
122 | 122 |
123 // Explicitly test specific versions. | 123 // Explicitly test specific versions. |
124 EXPECT_EQ(QUIC_VERSION_25, | 124 EXPECT_EQ(QUIC_VERSION_30, |
125 QuicTagToQuicVersion(MakeQuicTag('Q', '0', '2', '5'))); | 125 QuicTagToQuicVersion(MakeQuicTag('Q', '0', '3', '0'))); |
126 | 126 |
127 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { | 127 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { |
128 QuicVersion version = kSupportedQuicVersions[i]; | 128 QuicVersion version = kSupportedQuicVersions[i]; |
129 | 129 |
130 // Get the tag from the version (we can loop over QuicVersions easily). | 130 // Get the tag from the version (we can loop over QuicVersions easily). |
131 QuicTag tag = QuicVersionToQuicTag(version); | 131 QuicTag tag = QuicVersionToQuicTag(version); |
132 EXPECT_LT(0u, tag); | 132 EXPECT_LT(0u, tag); |
133 | 133 |
134 // Now try converting back. | 134 // Now try converting back. |
135 QuicVersion tag_to_quic_version = QuicTagToQuicVersion(tag); | 135 QuicVersion tag_to_quic_version = QuicTagToQuicVersion(tag); |
(...skipping 12 matching lines...) Expand all Loading... |
148 .Times(1); | 148 .Times(1); |
149 #endif | 149 #endif |
150 log.StartCapturingLogs(); | 150 log.StartCapturingLogs(); |
151 #endif | 151 #endif |
152 | 152 |
153 EXPECT_EQ(QUIC_VERSION_UNSUPPORTED, | 153 EXPECT_EQ(QUIC_VERSION_UNSUPPORTED, |
154 QuicTagToQuicVersion(MakeQuicTag('F', 'A', 'K', 'E'))); | 154 QuicTagToQuicVersion(MakeQuicTag('F', 'A', 'K', 'E'))); |
155 } | 155 } |
156 | 156 |
157 TEST(QuicProtocolTest, QuicVersionToString) { | 157 TEST(QuicProtocolTest, QuicVersionToString) { |
158 EXPECT_EQ("QUIC_VERSION_25", QuicVersionToString(QUIC_VERSION_25)); | 158 EXPECT_EQ("QUIC_VERSION_30", QuicVersionToString(QUIC_VERSION_30)); |
159 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED", | 159 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED", |
160 QuicVersionToString(QUIC_VERSION_UNSUPPORTED)); | 160 QuicVersionToString(QUIC_VERSION_UNSUPPORTED)); |
161 | 161 |
162 QuicVersion single_version[] = {QUIC_VERSION_25}; | 162 QuicVersion single_version[] = {QUIC_VERSION_30}; |
163 QuicVersionVector versions_vector; | 163 QuicVersionVector versions_vector; |
164 for (size_t i = 0; i < arraysize(single_version); ++i) { | 164 for (size_t i = 0; i < arraysize(single_version); ++i) { |
165 versions_vector.push_back(single_version[i]); | 165 versions_vector.push_back(single_version[i]); |
166 } | 166 } |
167 EXPECT_EQ("QUIC_VERSION_25", QuicVersionVectorToString(versions_vector)); | 167 EXPECT_EQ("QUIC_VERSION_30", QuicVersionVectorToString(versions_vector)); |
168 | 168 |
169 QuicVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED, QUIC_VERSION_25}; | 169 QuicVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED, QUIC_VERSION_30}; |
170 versions_vector.clear(); | 170 versions_vector.clear(); |
171 for (size_t i = 0; i < arraysize(multiple_versions); ++i) { | 171 for (size_t i = 0; i < arraysize(multiple_versions); ++i) { |
172 versions_vector.push_back(multiple_versions[i]); | 172 versions_vector.push_back(multiple_versions[i]); |
173 } | 173 } |
174 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_25", | 174 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_30", |
175 QuicVersionVectorToString(versions_vector)); | 175 QuicVersionVectorToString(versions_vector)); |
176 | 176 |
177 // Make sure that all supported versions are present in QuicVersionToString. | 177 // Make sure that all supported versions are present in QuicVersionToString. |
178 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { | 178 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { |
179 QuicVersion version = kSupportedQuicVersions[i]; | 179 QuicVersion version = kSupportedQuicVersions[i]; |
180 EXPECT_NE("QUIC_VERSION_UNSUPPORTED", QuicVersionToString(version)); | 180 EXPECT_NE("QUIC_VERSION_UNSUPPORTED", QuicVersionToString(version)); |
181 } | 181 } |
182 } | 182 } |
183 | 183 |
184 TEST(QuicProtocolTest, AckFrameToString) { | 184 TEST(QuicProtocolTest, AckFrameToString) { |
(...skipping 92 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
277 | 277 |
278 TEST(QuicProtocolTest, PathCloseFrameToString) { | 278 TEST(QuicProtocolTest, PathCloseFrameToString) { |
279 QuicPathCloseFrame frame; | 279 QuicPathCloseFrame frame; |
280 frame.path_id = 1; | 280 frame.path_id = 1; |
281 std::ostringstream stream; | 281 std::ostringstream stream; |
282 stream << frame; | 282 stream << frame; |
283 EXPECT_EQ("{ path_id: 1 }\n", stream.str()); | 283 EXPECT_EQ("{ path_id: 1 }\n", stream.str()); |
284 } | 284 } |
285 | 285 |
286 TEST(QuicProtocolTest, FilterSupportedVersions) { | 286 TEST(QuicProtocolTest, FilterSupportedVersions) { |
287 QuicVersionVector all_versions = {QUIC_VERSION_25, QUIC_VERSION_26, | 287 QuicVersionVector all_versions = { |
288 QUIC_VERSION_27, QUIC_VERSION_29, | 288 QUIC_VERSION_30, QUIC_VERSION_31, QUIC_VERSION_32, QUIC_VERSION_33, |
289 QUIC_VERSION_30}; | 289 QUIC_VERSION_34, QUIC_VERSION_35, QUIC_VERSION_36}; |
290 | 290 |
291 FLAGS_quic_disable_pre_30 = true; | 291 FLAGS_quic_enable_version_35 = false; |
| 292 FLAGS_quic_enable_version_36 = false; |
| 293 |
292 QuicVersionVector filtered_versions = FilterSupportedVersions(all_versions); | 294 QuicVersionVector filtered_versions = FilterSupportedVersions(all_versions); |
293 ASSERT_EQ(1u, filtered_versions.size()); | 295 ASSERT_EQ(5u, filtered_versions.size()); |
294 EXPECT_EQ(QUIC_VERSION_30, filtered_versions[0]); | 296 EXPECT_EQ(QUIC_VERSION_30, filtered_versions[0]); |
| 297 EXPECT_EQ(QUIC_VERSION_31, filtered_versions[1]); |
| 298 EXPECT_EQ(QUIC_VERSION_32, filtered_versions[2]); |
| 299 EXPECT_EQ(QUIC_VERSION_33, filtered_versions[3]); |
| 300 EXPECT_EQ(QUIC_VERSION_34, filtered_versions[4]); |
295 } | 301 } |
296 | 302 |
297 // Tests that a queue contains the expected data after calls to Add(). | 303 // Tests that a queue contains the expected data after calls to Add(). |
298 TEST(PacketNumberQueueTest, AddRange) { | 304 TEST(PacketNumberQueueTest, AddRange) { |
299 PacketNumberQueue queue; | 305 PacketNumberQueue queue; |
300 queue.Add(1, 51); | 306 queue.Add(1, 51); |
301 queue.Add(53); | 307 queue.Add(53); |
302 | 308 |
303 EXPECT_FALSE(queue.Contains(0)); | 309 EXPECT_FALSE(queue.Contains(0)); |
304 for (int i = 1; i < 51; ++i) { | 310 for (int i = 1; i < 51; ++i) { |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
409 EXPECT_EQ(2u, queue.NumIntervals()); | 415 EXPECT_EQ(2u, queue.NumIntervals()); |
410 EXPECT_TRUE(queue.Contains(10)); | 416 EXPECT_TRUE(queue.Contains(10)); |
411 EXPECT_TRUE(queue.Contains(11)); | 417 EXPECT_TRUE(queue.Contains(11)); |
412 EXPECT_TRUE(queue.Contains(20)); | 418 EXPECT_TRUE(queue.Contains(20)); |
413 EXPECT_TRUE(queue.Contains(21)); | 419 EXPECT_TRUE(queue.Contains(21)); |
414 } | 420 } |
415 | 421 |
416 } // namespace | 422 } // namespace |
417 } // namespace test | 423 } // namespace test |
418 } // namespace net | 424 } // namespace net |
OLD | NEW |