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/core/quic_versions.h" | 5 #include "net/quic/core/quic_versions.h" |
6 | 6 |
7 #include "net/quic/core/quic_flags.h" | 7 #include "net/quic/core/quic_flags.h" |
8 #include "net/quic/test_tools/quic_test_utils.h" | 8 #include "net/quic/test_tools/quic_test_utils.h" |
9 #include "testing/gtest/include/gtest/gtest.h" | 9 #include "testing/gtest/include/gtest/gtest.h" |
10 | 10 |
11 namespace net { | 11 namespace net { |
12 namespace test { | 12 namespace test { |
13 namespace { | 13 namespace { |
14 | 14 |
15 TEST(QuicVersionsTest, QuicVersionToQuicTag) { | 15 TEST(QuicVersionsTest, QuicVersionToQuicTag) { |
16 // If you add a new version to the QuicVersion enum you will need to add a new | 16 // If you add a new version to the QuicVersion enum you will need to add a new |
17 // case to QuicVersionToQuicTag, otherwise this test will fail. | 17 // case to QuicVersionToQuicTag, otherwise this test will fail. |
18 | 18 |
19 // TODO(rtenneti): Enable checking of Log(ERROR) messages. | 19 // TODO(rtenneti): Enable checking of Log(ERROR) messages. |
20 #if 0 | 20 #if 0 |
21 // Any logs would indicate an unsupported version which we don't expect. | 21 // Any logs would indicate an unsupported version which we don't expect. |
22 ScopedMockLog log(kDoNotCaptureLogsYet); | 22 ScopedMockLog log(kDoNotCaptureLogsYet); |
23 EXPECT_CALL(log, Log(_, _, _)).Times(0); | 23 EXPECT_CALL(log, Log(_, _, _)).Times(0); |
24 log.StartCapturingLogs(); | 24 log.StartCapturingLogs(); |
25 #endif | 25 #endif |
26 | 26 |
27 // Explicitly test a specific version. | 27 // Explicitly test a specific version. |
28 EXPECT_EQ(MakeQuicTag('Q', '0', '3', '4'), | 28 EXPECT_EQ(MakeQuicTag('Q', '0', '3', '5'), |
29 QuicVersionToQuicTag(QUIC_VERSION_34)); | 29 QuicVersionToQuicTag(QUIC_VERSION_35)); |
30 | 30 |
31 // Loop over all supported versions and make sure that we never hit the | 31 // Loop over all supported versions and make sure that we never hit the |
32 // default case (i.e. all supported versions should be successfully converted | 32 // default case (i.e. all supported versions should be successfully converted |
33 // to valid QuicTags). | 33 // to valid QuicTags). |
34 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { | 34 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { |
35 QuicVersion version = kSupportedQuicVersions[i]; | 35 QuicVersion version = kSupportedQuicVersions[i]; |
36 EXPECT_LT(0u, QuicVersionToQuicTag(version)); | 36 EXPECT_LT(0u, QuicVersionToQuicTag(version)); |
37 } | 37 } |
38 } | 38 } |
39 | 39 |
(...skipping 18 matching lines...) Expand all Loading... |
58 | 58 |
59 // TODO(rtenneti): Enable checking of Log(ERROR) messages. | 59 // TODO(rtenneti): Enable checking of Log(ERROR) messages. |
60 #if 0 | 60 #if 0 |
61 // Any logs would indicate an unsupported version which we don't expect. | 61 // Any logs would indicate an unsupported version which we don't expect. |
62 ScopedMockLog log(kDoNotCaptureLogsYet); | 62 ScopedMockLog log(kDoNotCaptureLogsYet); |
63 EXPECT_CALL(log, Log(_, _, _)).Times(0); | 63 EXPECT_CALL(log, Log(_, _, _)).Times(0); |
64 log.StartCapturingLogs(); | 64 log.StartCapturingLogs(); |
65 #endif | 65 #endif |
66 | 66 |
67 // Explicitly test specific versions. | 67 // Explicitly test specific versions. |
68 EXPECT_EQ(QUIC_VERSION_34, | 68 EXPECT_EQ(QUIC_VERSION_35, |
69 QuicTagToQuicVersion(MakeQuicTag('Q', '0', '3', '4'))); | 69 QuicTagToQuicVersion(MakeQuicTag('Q', '0', '3', '5'))); |
70 | 70 |
71 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { | 71 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { |
72 QuicVersion version = kSupportedQuicVersions[i]; | 72 QuicVersion version = kSupportedQuicVersions[i]; |
73 | 73 |
74 // Get the tag from the version (we can loop over QuicVersions easily). | 74 // Get the tag from the version (we can loop over QuicVersions easily). |
75 QuicTag tag = QuicVersionToQuicTag(version); | 75 QuicTag tag = QuicVersionToQuicTag(version); |
76 EXPECT_LT(0u, tag); | 76 EXPECT_LT(0u, tag); |
77 | 77 |
78 // Now try converting back. | 78 // Now try converting back. |
79 QuicVersion tag_to_quic_version = QuicTagToQuicVersion(tag); | 79 QuicVersion tag_to_quic_version = QuicTagToQuicVersion(tag); |
(...skipping 12 matching lines...) Expand all Loading... |
92 .Times(1); | 92 .Times(1); |
93 #endif | 93 #endif |
94 log.StartCapturingLogs(); | 94 log.StartCapturingLogs(); |
95 #endif | 95 #endif |
96 | 96 |
97 EXPECT_EQ(QUIC_VERSION_UNSUPPORTED, | 97 EXPECT_EQ(QUIC_VERSION_UNSUPPORTED, |
98 QuicTagToQuicVersion(MakeQuicTag('F', 'A', 'K', 'E'))); | 98 QuicTagToQuicVersion(MakeQuicTag('F', 'A', 'K', 'E'))); |
99 } | 99 } |
100 | 100 |
101 TEST(QuicVersionsTest, QuicVersionToString) { | 101 TEST(QuicVersionsTest, QuicVersionToString) { |
102 EXPECT_EQ("QUIC_VERSION_34", QuicVersionToString(QUIC_VERSION_34)); | 102 EXPECT_EQ("QUIC_VERSION_35", QuicVersionToString(QUIC_VERSION_35)); |
103 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED", | 103 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED", |
104 QuicVersionToString(QUIC_VERSION_UNSUPPORTED)); | 104 QuicVersionToString(QUIC_VERSION_UNSUPPORTED)); |
105 | 105 |
106 QuicVersion single_version[] = {QUIC_VERSION_34}; | 106 QuicVersion single_version[] = {QUIC_VERSION_35}; |
107 QuicVersionVector versions_vector; | 107 QuicVersionVector versions_vector; |
108 for (size_t i = 0; i < arraysize(single_version); ++i) { | 108 for (size_t i = 0; i < arraysize(single_version); ++i) { |
109 versions_vector.push_back(single_version[i]); | 109 versions_vector.push_back(single_version[i]); |
110 } | 110 } |
111 EXPECT_EQ("QUIC_VERSION_34", QuicVersionVectorToString(versions_vector)); | 111 EXPECT_EQ("QUIC_VERSION_35", QuicVersionVectorToString(versions_vector)); |
112 | 112 |
113 QuicVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED, QUIC_VERSION_34}; | 113 QuicVersion multiple_versions[] = {QUIC_VERSION_UNSUPPORTED, QUIC_VERSION_35}; |
114 versions_vector.clear(); | 114 versions_vector.clear(); |
115 for (size_t i = 0; i < arraysize(multiple_versions); ++i) { | 115 for (size_t i = 0; i < arraysize(multiple_versions); ++i) { |
116 versions_vector.push_back(multiple_versions[i]); | 116 versions_vector.push_back(multiple_versions[i]); |
117 } | 117 } |
118 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_34", | 118 EXPECT_EQ("QUIC_VERSION_UNSUPPORTED,QUIC_VERSION_35", |
119 QuicVersionVectorToString(versions_vector)); | 119 QuicVersionVectorToString(versions_vector)); |
120 | 120 |
121 // Make sure that all supported versions are present in QuicVersionToString. | 121 // Make sure that all supported versions are present in QuicVersionToString. |
122 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { | 122 for (size_t i = 0; i < arraysize(kSupportedQuicVersions); ++i) { |
123 QuicVersion version = kSupportedQuicVersions[i]; | 123 QuicVersion version = kSupportedQuicVersions[i]; |
124 EXPECT_NE("QUIC_VERSION_UNSUPPORTED", QuicVersionToString(version)); | 124 EXPECT_NE("QUIC_VERSION_UNSUPPORTED", QuicVersionToString(version)); |
125 } | 125 } |
126 } | 126 } |
127 | 127 |
128 TEST(QuicVersionsTest, FilterSupportedVersionsNo34) { | 128 TEST(QuicVersionsTest, FilterSupportedVersionsNo36) { |
129 QuicFlagSaver flags; | 129 QuicFlagSaver flags; |
130 QuicVersionVector all_versions = {QUIC_VERSION_34, QUIC_VERSION_35, | 130 QuicVersionVector all_versions = {QUIC_VERSION_35, QUIC_VERSION_36, |
131 QUIC_VERSION_36, QUIC_VERSION_37}; | 131 QUIC_VERSION_37}; |
132 | 132 |
133 FLAGS_quic_reloadable_flag_quic_disable_version_34 = true; | |
134 FLAGS_quic_reloadable_flag_quic_enable_version_36_v3 = false; | 133 FLAGS_quic_reloadable_flag_quic_enable_version_36_v3 = false; |
135 FLAGS_quic_reloadable_flag_quic_enable_version_37 = false; | 134 FLAGS_quic_reloadable_flag_quic_enable_version_37 = false; |
136 | 135 |
137 QuicVersionVector filtered_versions = FilterSupportedVersions(all_versions); | 136 QuicVersionVector filtered_versions = FilterSupportedVersions(all_versions); |
138 ASSERT_EQ(1u, filtered_versions.size()); | 137 ASSERT_EQ(1u, filtered_versions.size()); |
139 EXPECT_EQ(QUIC_VERSION_35, filtered_versions[0]); | 138 EXPECT_EQ(QUIC_VERSION_35, filtered_versions[0]); |
140 } | 139 } |
141 | 140 |
142 TEST(QuicVersionsTest, FilterSupportedVersionsNo36) { | 141 TEST(QuicVersionsTest, FilterSupportedVersionsNo37) { |
143 QuicFlagSaver flags; | 142 QuicFlagSaver flags; |
144 QuicVersionVector all_versions = {QUIC_VERSION_34, QUIC_VERSION_35, | 143 QuicVersionVector all_versions = {QUIC_VERSION_35, QUIC_VERSION_36, |
145 QUIC_VERSION_36, QUIC_VERSION_37}; | 144 QUIC_VERSION_37}; |
146 | 145 |
147 FLAGS_quic_reloadable_flag_quic_disable_version_34 = false; | 146 FLAGS_quic_reloadable_flag_quic_enable_version_36_v3 = true; |
148 FLAGS_quic_reloadable_flag_quic_enable_version_36_v3 = false; | |
149 FLAGS_quic_reloadable_flag_quic_enable_version_37 = false; | 147 FLAGS_quic_reloadable_flag_quic_enable_version_37 = false; |
150 | 148 |
151 QuicVersionVector filtered_versions = FilterSupportedVersions(all_versions); | 149 QuicVersionVector filtered_versions = FilterSupportedVersions(all_versions); |
152 ASSERT_EQ(2u, filtered_versions.size()); | 150 ASSERT_EQ(2u, filtered_versions.size()); |
153 EXPECT_EQ(QUIC_VERSION_34, filtered_versions[0]); | 151 EXPECT_EQ(QUIC_VERSION_35, filtered_versions[0]); |
154 EXPECT_EQ(QUIC_VERSION_35, filtered_versions[1]); | 152 EXPECT_EQ(QUIC_VERSION_36, filtered_versions[1]); |
155 } | |
156 | |
157 TEST(QuicVersionsTest, FilterSupportedVersionsNo37) { | |
158 QuicFlagSaver flags; | |
159 QuicVersionVector all_versions = {QUIC_VERSION_34, QUIC_VERSION_35, | |
160 QUIC_VERSION_36, QUIC_VERSION_37}; | |
161 | |
162 FLAGS_quic_reloadable_flag_quic_disable_version_34 = false; | |
163 FLAGS_quic_reloadable_flag_quic_enable_version_36_v3 = true; | |
164 FLAGS_quic_reloadable_flag_quic_enable_version_37 = false; | |
165 | |
166 QuicVersionVector filtered_versions = FilterSupportedVersions(all_versions); | |
167 ASSERT_EQ(3u, filtered_versions.size()); | |
168 EXPECT_EQ(QUIC_VERSION_34, filtered_versions[0]); | |
169 EXPECT_EQ(QUIC_VERSION_35, filtered_versions[1]); | |
170 EXPECT_EQ(QUIC_VERSION_36, filtered_versions[2]); | |
171 } | 153 } |
172 | 154 |
173 TEST(QuicVersionsTest, FilterSupportedVersionsAllVersions) { | 155 TEST(QuicVersionsTest, FilterSupportedVersionsAllVersions) { |
174 QuicFlagSaver flags; | 156 QuicFlagSaver flags; |
175 QuicVersionVector all_versions = {QUIC_VERSION_34, QUIC_VERSION_35, | 157 QuicVersionVector all_versions = {QUIC_VERSION_35, QUIC_VERSION_36, |
176 QUIC_VERSION_36, QUIC_VERSION_37}; | 158 QUIC_VERSION_37}; |
177 | 159 |
178 FLAGS_quic_reloadable_flag_quic_disable_version_34 = false; | |
179 FLAGS_quic_reloadable_flag_quic_enable_version_36_v3 = true; | 160 FLAGS_quic_reloadable_flag_quic_enable_version_36_v3 = true; |
180 FLAGS_quic_reloadable_flag_quic_enable_version_37 = true; | 161 FLAGS_quic_reloadable_flag_quic_enable_version_37 = true; |
181 | 162 |
182 QuicVersionVector filtered_versions = FilterSupportedVersions(all_versions); | 163 QuicVersionVector filtered_versions = FilterSupportedVersions(all_versions); |
183 ASSERT_EQ(all_versions, filtered_versions); | 164 ASSERT_EQ(all_versions, filtered_versions); |
184 } | 165 } |
185 | 166 |
186 TEST(QuicVersionsTest, LookUpVersionByIndex) { | 167 TEST(QuicVersionsTest, LookUpVersionByIndex) { |
187 QuicVersionVector all_versions = {QUIC_VERSION_34, QUIC_VERSION_35, | 168 QuicVersionVector all_versions = {QUIC_VERSION_35, QUIC_VERSION_36, |
188 QUIC_VERSION_36, QUIC_VERSION_37}; | 169 QUIC_VERSION_37}; |
189 int version_count = all_versions.size(); | 170 int version_count = all_versions.size(); |
190 for (int i = -5; i <= version_count + 1; ++i) { | 171 for (int i = -5; i <= version_count + 1; ++i) { |
191 if (i >= 0 && i < version_count) { | 172 if (i >= 0 && i < version_count) { |
192 EXPECT_EQ(all_versions[i], VersionOfIndex(all_versions, i)[0]); | 173 EXPECT_EQ(all_versions[i], VersionOfIndex(all_versions, i)[0]); |
193 } else { | 174 } else { |
194 EXPECT_EQ(QUIC_VERSION_UNSUPPORTED, VersionOfIndex(all_versions, i)[0]); | 175 EXPECT_EQ(QUIC_VERSION_UNSUPPORTED, VersionOfIndex(all_versions, i)[0]); |
195 } | 176 } |
196 } | 177 } |
197 } | 178 } |
198 | 179 |
199 } // namespace | 180 } // namespace |
200 } // namespace test | 181 } // namespace test |
201 } // namespace net | 182 } // namespace net |
OLD | NEW |