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