OLD | NEW |
| (Empty) |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include "net/http2/http2_constants.h" | |
6 #include "testing/gtest/include/gtest/gtest.h" | |
7 | |
8 namespace net { | |
9 namespace test { | |
10 namespace { | |
11 | |
12 class Http2ConstantsTest : public testing::Test {}; | |
13 | |
14 TEST(Http2ConstantsTest, Http2FrameType) { | |
15 EXPECT_EQ(Http2FrameType::DATA, static_cast<Http2FrameType>(0)); | |
16 EXPECT_EQ(Http2FrameType::HEADERS, static_cast<Http2FrameType>(1)); | |
17 EXPECT_EQ(Http2FrameType::PRIORITY, static_cast<Http2FrameType>(2)); | |
18 EXPECT_EQ(Http2FrameType::RST_STREAM, static_cast<Http2FrameType>(3)); | |
19 EXPECT_EQ(Http2FrameType::SETTINGS, static_cast<Http2FrameType>(4)); | |
20 EXPECT_EQ(Http2FrameType::PUSH_PROMISE, static_cast<Http2FrameType>(5)); | |
21 EXPECT_EQ(Http2FrameType::PING, static_cast<Http2FrameType>(6)); | |
22 EXPECT_EQ(Http2FrameType::GOAWAY, static_cast<Http2FrameType>(7)); | |
23 EXPECT_EQ(Http2FrameType::WINDOW_UPDATE, static_cast<Http2FrameType>(8)); | |
24 EXPECT_EQ(Http2FrameType::CONTINUATION, static_cast<Http2FrameType>(9)); | |
25 EXPECT_EQ(Http2FrameType::ALTSVC, static_cast<Http2FrameType>(10)); | |
26 } | |
27 | |
28 TEST(Http2ConstantsTest, Http2FrameTypeToString) { | |
29 EXPECT_EQ("DATA", Http2FrameTypeToString(Http2FrameType::DATA)); | |
30 EXPECT_EQ("HEADERS", Http2FrameTypeToString(Http2FrameType::HEADERS)); | |
31 EXPECT_EQ("PRIORITY", Http2FrameTypeToString(Http2FrameType::PRIORITY)); | |
32 EXPECT_EQ("RST_STREAM", Http2FrameTypeToString(Http2FrameType::RST_STREAM)); | |
33 EXPECT_EQ("SETTINGS", Http2FrameTypeToString(Http2FrameType::SETTINGS)); | |
34 EXPECT_EQ("PUSH_PROMISE", | |
35 Http2FrameTypeToString(Http2FrameType::PUSH_PROMISE)); | |
36 EXPECT_EQ("PING", Http2FrameTypeToString(Http2FrameType::PING)); | |
37 EXPECT_EQ("GOAWAY", Http2FrameTypeToString(Http2FrameType::GOAWAY)); | |
38 EXPECT_EQ("WINDOW_UPDATE", | |
39 Http2FrameTypeToString(Http2FrameType::WINDOW_UPDATE)); | |
40 EXPECT_EQ("CONTINUATION", | |
41 Http2FrameTypeToString(Http2FrameType::CONTINUATION)); | |
42 EXPECT_EQ("ALTSVC", Http2FrameTypeToString(Http2FrameType::ALTSVC)); | |
43 | |
44 EXPECT_EQ("DATA", Http2FrameTypeToString(0)); | |
45 EXPECT_EQ("HEADERS", Http2FrameTypeToString(1)); | |
46 EXPECT_EQ("PRIORITY", Http2FrameTypeToString(2)); | |
47 EXPECT_EQ("RST_STREAM", Http2FrameTypeToString(3)); | |
48 EXPECT_EQ("SETTINGS", Http2FrameTypeToString(4)); | |
49 EXPECT_EQ("PUSH_PROMISE", Http2FrameTypeToString(5)); | |
50 EXPECT_EQ("PING", Http2FrameTypeToString(6)); | |
51 EXPECT_EQ("GOAWAY", Http2FrameTypeToString(7)); | |
52 EXPECT_EQ("WINDOW_UPDATE", Http2FrameTypeToString(8)); | |
53 EXPECT_EQ("CONTINUATION", Http2FrameTypeToString(9)); | |
54 EXPECT_EQ("ALTSVC", Http2FrameTypeToString(10)); | |
55 | |
56 EXPECT_EQ("UnknownFrameType(99)", Http2FrameTypeToString(99)); | |
57 } | |
58 | |
59 TEST(Http2ConstantsTest, Http2FrameFlag) { | |
60 EXPECT_EQ(Http2FrameFlag::FLAG_END_STREAM, static_cast<Http2FrameFlag>(0x01)); | |
61 EXPECT_EQ(Http2FrameFlag::FLAG_ACK, static_cast<Http2FrameFlag>(0x01)); | |
62 EXPECT_EQ(Http2FrameFlag::FLAG_END_HEADERS, | |
63 static_cast<Http2FrameFlag>(0x04)); | |
64 EXPECT_EQ(Http2FrameFlag::FLAG_PADDED, static_cast<Http2FrameFlag>(0x08)); | |
65 EXPECT_EQ(Http2FrameFlag::FLAG_PRIORITY, static_cast<Http2FrameFlag>(0x20)); | |
66 | |
67 EXPECT_EQ(Http2FrameFlag::FLAG_END_STREAM, 0x01); | |
68 EXPECT_EQ(Http2FrameFlag::FLAG_ACK, 0x01); | |
69 EXPECT_EQ(Http2FrameFlag::FLAG_END_HEADERS, 0x04); | |
70 EXPECT_EQ(Http2FrameFlag::FLAG_PADDED, 0x08); | |
71 EXPECT_EQ(Http2FrameFlag::FLAG_PRIORITY, 0x20); | |
72 } | |
73 | |
74 TEST(Http2ConstantsTest, Http2FrameFlagsToString) { | |
75 // Single flags... | |
76 | |
77 // 0b00000001 | |
78 EXPECT_EQ("END_STREAM", | |
79 Http2FrameFlagsToString(Http2FrameType::DATA, | |
80 Http2FrameFlag::FLAG_END_STREAM)); | |
81 EXPECT_EQ("END_STREAM", | |
82 Http2FrameFlagsToString(Http2FrameType::HEADERS, 0x01)); | |
83 EXPECT_EQ("ACK", Http2FrameFlagsToString(Http2FrameType::SETTINGS, | |
84 Http2FrameFlag::FLAG_ACK)); | |
85 EXPECT_EQ("ACK", Http2FrameFlagsToString(Http2FrameType::PING, 0x01)); | |
86 | |
87 // 0b00000010 | |
88 EXPECT_EQ("0x02", Http2FrameFlagsToString(0xff, 0x02)); | |
89 | |
90 // 0b00000100 | |
91 EXPECT_EQ("END_HEADERS", | |
92 Http2FrameFlagsToString(Http2FrameType::HEADERS, | |
93 Http2FrameFlag::FLAG_END_HEADERS)); | |
94 EXPECT_EQ("END_HEADERS", | |
95 Http2FrameFlagsToString(Http2FrameType::PUSH_PROMISE, 0x04)); | |
96 EXPECT_EQ("END_HEADERS", Http2FrameFlagsToString(0x09, 0x04)); | |
97 EXPECT_EQ("0x04", Http2FrameFlagsToString(0xff, 0x04)); | |
98 | |
99 // 0b00001000 | |
100 EXPECT_EQ("PADDED", Http2FrameFlagsToString(Http2FrameType::DATA, | |
101 Http2FrameFlag::FLAG_PADDED)); | |
102 EXPECT_EQ("PADDED", Http2FrameFlagsToString(Http2FrameType::HEADERS, 0x08)); | |
103 EXPECT_EQ("PADDED", Http2FrameFlagsToString(0x05, 0x08)); | |
104 EXPECT_EQ("0x08", Http2FrameFlagsToString(0xff, Http2FrameFlag::FLAG_PADDED)); | |
105 | |
106 // 0b00010000 | |
107 EXPECT_EQ("0x10", Http2FrameFlagsToString(Http2FrameType::SETTINGS, 0x10)); | |
108 | |
109 // 0b00100000 | |
110 EXPECT_EQ("PRIORITY", Http2FrameFlagsToString(Http2FrameType::HEADERS, 0x20)); | |
111 EXPECT_EQ("0x20", | |
112 Http2FrameFlagsToString(Http2FrameType::PUSH_PROMISE, 0x20)); | |
113 | |
114 // 0b01000000 | |
115 EXPECT_EQ("0x40", Http2FrameFlagsToString(0xff, 0x40)); | |
116 | |
117 // 0b10000000 | |
118 EXPECT_EQ("0x80", Http2FrameFlagsToString(0xff, 0x80)); | |
119 | |
120 // Combined flags... | |
121 | |
122 EXPECT_EQ("END_STREAM|PADDED|0xf6", | |
123 Http2FrameFlagsToString(Http2FrameType::DATA, 0xff)); | |
124 EXPECT_EQ("END_STREAM|END_HEADERS|PADDED|PRIORITY|0xd2", | |
125 Http2FrameFlagsToString(Http2FrameType::HEADERS, 0xff)); | |
126 EXPECT_EQ("0xff", Http2FrameFlagsToString(Http2FrameType::PRIORITY, 0xff)); | |
127 EXPECT_EQ("0xff", Http2FrameFlagsToString(Http2FrameType::RST_STREAM, 0xff)); | |
128 EXPECT_EQ("ACK|0xfe", | |
129 Http2FrameFlagsToString(Http2FrameType::SETTINGS, 0xff)); | |
130 EXPECT_EQ("END_HEADERS|PADDED|0xf3", | |
131 Http2FrameFlagsToString(Http2FrameType::PUSH_PROMISE, 0xff)); | |
132 EXPECT_EQ("ACK|0xfe", Http2FrameFlagsToString(Http2FrameType::PING, 0xff)); | |
133 EXPECT_EQ("0xff", Http2FrameFlagsToString(Http2FrameType::GOAWAY, 0xff)); | |
134 EXPECT_EQ("0xff", | |
135 Http2FrameFlagsToString(Http2FrameType::WINDOW_UPDATE, 0xff)); | |
136 EXPECT_EQ("END_HEADERS|0xfb", | |
137 Http2FrameFlagsToString(Http2FrameType::CONTINUATION, 0xff)); | |
138 EXPECT_EQ("0xff", Http2FrameFlagsToString(Http2FrameType::ALTSVC, 0xff)); | |
139 EXPECT_EQ("0xff", Http2FrameFlagsToString(0xff, 0xff)); | |
140 } | |
141 | |
142 TEST(Http2ConstantsTest, Http2ErrorCode) { | |
143 EXPECT_EQ(Http2ErrorCode::HTTP2_NO_ERROR, static_cast<Http2ErrorCode>(0x0)); | |
144 EXPECT_EQ(Http2ErrorCode::PROTOCOL_ERROR, static_cast<Http2ErrorCode>(0x1)); | |
145 EXPECT_EQ(Http2ErrorCode::INTERNAL_ERROR, static_cast<Http2ErrorCode>(0x2)); | |
146 EXPECT_EQ(Http2ErrorCode::FLOW_CONTROL_ERROR, | |
147 static_cast<Http2ErrorCode>(0x3)); | |
148 EXPECT_EQ(Http2ErrorCode::SETTINGS_TIMEOUT, static_cast<Http2ErrorCode>(0x4)); | |
149 EXPECT_EQ(Http2ErrorCode::STREAM_CLOSED, static_cast<Http2ErrorCode>(0x5)); | |
150 EXPECT_EQ(Http2ErrorCode::FRAME_SIZE_ERROR, static_cast<Http2ErrorCode>(0x6)); | |
151 EXPECT_EQ(Http2ErrorCode::REFUSED_STREAM, static_cast<Http2ErrorCode>(0x7)); | |
152 EXPECT_EQ(Http2ErrorCode::CANCEL, static_cast<Http2ErrorCode>(0x8)); | |
153 EXPECT_EQ(Http2ErrorCode::COMPRESSION_ERROR, | |
154 static_cast<Http2ErrorCode>(0x9)); | |
155 EXPECT_EQ(Http2ErrorCode::CONNECT_ERROR, static_cast<Http2ErrorCode>(0xa)); | |
156 EXPECT_EQ(Http2ErrorCode::ENHANCE_YOUR_CALM, | |
157 static_cast<Http2ErrorCode>(0xb)); | |
158 EXPECT_EQ(Http2ErrorCode::INADEQUATE_SECURITY, | |
159 static_cast<Http2ErrorCode>(0xc)); | |
160 EXPECT_EQ(Http2ErrorCode::HTTP_1_1_REQUIRED, | |
161 static_cast<Http2ErrorCode>(0xd)); | |
162 } | |
163 | |
164 TEST(Http2ConstantsTest, Http2ErrorCodeToString) { | |
165 EXPECT_EQ("NO_ERROR", Http2ErrorCodeToString(Http2ErrorCode::HTTP2_NO_ERROR)); | |
166 EXPECT_EQ("NO_ERROR", Http2ErrorCodeToString(0x0)); | |
167 EXPECT_EQ("PROTOCOL_ERROR", | |
168 Http2ErrorCodeToString(Http2ErrorCode::PROTOCOL_ERROR)); | |
169 EXPECT_EQ("PROTOCOL_ERROR", Http2ErrorCodeToString(0x1)); | |
170 EXPECT_EQ("INTERNAL_ERROR", | |
171 Http2ErrorCodeToString(Http2ErrorCode::INTERNAL_ERROR)); | |
172 EXPECT_EQ("INTERNAL_ERROR", Http2ErrorCodeToString(0x2)); | |
173 EXPECT_EQ("FLOW_CONTROL_ERROR", | |
174 Http2ErrorCodeToString(Http2ErrorCode::FLOW_CONTROL_ERROR)); | |
175 EXPECT_EQ("FLOW_CONTROL_ERROR", Http2ErrorCodeToString(0x3)); | |
176 EXPECT_EQ("SETTINGS_TIMEOUT", | |
177 Http2ErrorCodeToString(Http2ErrorCode::SETTINGS_TIMEOUT)); | |
178 EXPECT_EQ("SETTINGS_TIMEOUT", Http2ErrorCodeToString(0x4)); | |
179 EXPECT_EQ("STREAM_CLOSED", | |
180 Http2ErrorCodeToString(Http2ErrorCode::STREAM_CLOSED)); | |
181 EXPECT_EQ("STREAM_CLOSED", Http2ErrorCodeToString(0x5)); | |
182 EXPECT_EQ("FRAME_SIZE_ERROR", | |
183 Http2ErrorCodeToString(Http2ErrorCode::FRAME_SIZE_ERROR)); | |
184 EXPECT_EQ("FRAME_SIZE_ERROR", Http2ErrorCodeToString(0x6)); | |
185 EXPECT_EQ("REFUSED_STREAM", | |
186 Http2ErrorCodeToString(Http2ErrorCode::REFUSED_STREAM)); | |
187 EXPECT_EQ("REFUSED_STREAM", Http2ErrorCodeToString(0x7)); | |
188 EXPECT_EQ("CANCEL", Http2ErrorCodeToString(Http2ErrorCode::CANCEL)); | |
189 EXPECT_EQ("CANCEL", Http2ErrorCodeToString(0x8)); | |
190 EXPECT_EQ("COMPRESSION_ERROR", | |
191 Http2ErrorCodeToString(Http2ErrorCode::COMPRESSION_ERROR)); | |
192 EXPECT_EQ("COMPRESSION_ERROR", Http2ErrorCodeToString(0x9)); | |
193 EXPECT_EQ("CONNECT_ERROR", | |
194 Http2ErrorCodeToString(Http2ErrorCode::CONNECT_ERROR)); | |
195 EXPECT_EQ("CONNECT_ERROR", Http2ErrorCodeToString(0xa)); | |
196 EXPECT_EQ("ENHANCE_YOUR_CALM", | |
197 Http2ErrorCodeToString(Http2ErrorCode::ENHANCE_YOUR_CALM)); | |
198 EXPECT_EQ("ENHANCE_YOUR_CALM", Http2ErrorCodeToString(0xb)); | |
199 EXPECT_EQ("INADEQUATE_SECURITY", | |
200 Http2ErrorCodeToString(Http2ErrorCode::INADEQUATE_SECURITY)); | |
201 EXPECT_EQ("INADEQUATE_SECURITY", Http2ErrorCodeToString(0xc)); | |
202 EXPECT_EQ("HTTP_1_1_REQUIRED", | |
203 Http2ErrorCodeToString(Http2ErrorCode::HTTP_1_1_REQUIRED)); | |
204 EXPECT_EQ("HTTP_1_1_REQUIRED", Http2ErrorCodeToString(0xd)); | |
205 | |
206 EXPECT_EQ("UnknownErrorCode(0x123)", Http2ErrorCodeToString(0x123)); | |
207 } | |
208 | |
209 TEST(Http2ConstantsTest, Http2SettingsParameter) { | |
210 EXPECT_EQ(Http2SettingsParameter::HEADER_TABLE_SIZE, | |
211 static_cast<Http2SettingsParameter>(0x1)); | |
212 EXPECT_EQ(Http2SettingsParameter::ENABLE_PUSH, | |
213 static_cast<Http2SettingsParameter>(0x2)); | |
214 EXPECT_EQ(Http2SettingsParameter::MAX_CONCURRENT_STREAMS, | |
215 static_cast<Http2SettingsParameter>(0x3)); | |
216 EXPECT_EQ(Http2SettingsParameter::INITIAL_WINDOW_SIZE, | |
217 static_cast<Http2SettingsParameter>(0x4)); | |
218 EXPECT_EQ(Http2SettingsParameter::MAX_FRAME_SIZE, | |
219 static_cast<Http2SettingsParameter>(0x5)); | |
220 EXPECT_EQ(Http2SettingsParameter::MAX_HEADER_LIST_SIZE, | |
221 static_cast<Http2SettingsParameter>(0x6)); | |
222 | |
223 EXPECT_TRUE(IsSupportedHttp2SettingsParameter( | |
224 Http2SettingsParameter::HEADER_TABLE_SIZE)); | |
225 EXPECT_TRUE( | |
226 IsSupportedHttp2SettingsParameter(Http2SettingsParameter::ENABLE_PUSH)); | |
227 EXPECT_TRUE(IsSupportedHttp2SettingsParameter( | |
228 Http2SettingsParameter::MAX_CONCURRENT_STREAMS)); | |
229 EXPECT_TRUE(IsSupportedHttp2SettingsParameter( | |
230 Http2SettingsParameter::INITIAL_WINDOW_SIZE)); | |
231 EXPECT_TRUE(IsSupportedHttp2SettingsParameter( | |
232 Http2SettingsParameter::MAX_FRAME_SIZE)); | |
233 EXPECT_TRUE(IsSupportedHttp2SettingsParameter( | |
234 Http2SettingsParameter::MAX_HEADER_LIST_SIZE)); | |
235 | |
236 EXPECT_FALSE(IsSupportedHttp2SettingsParameter( | |
237 static_cast<Http2SettingsParameter>(0))); | |
238 EXPECT_FALSE(IsSupportedHttp2SettingsParameter( | |
239 static_cast<Http2SettingsParameter>(7))); | |
240 } | |
241 | |
242 TEST(Http2ConstantsTest, Http2SettingsParameterToString) { | |
243 EXPECT_EQ("HEADER_TABLE_SIZE", | |
244 Http2SettingsParameterToString( | |
245 Http2SettingsParameter::HEADER_TABLE_SIZE)); | |
246 EXPECT_EQ("HEADER_TABLE_SIZE", Http2SettingsParameterToString(0x1)); | |
247 EXPECT_EQ("ENABLE_PUSH", Http2SettingsParameterToString( | |
248 Http2SettingsParameter::ENABLE_PUSH)); | |
249 EXPECT_EQ("ENABLE_PUSH", Http2SettingsParameterToString(0x2)); | |
250 EXPECT_EQ("MAX_CONCURRENT_STREAMS", | |
251 Http2SettingsParameterToString( | |
252 Http2SettingsParameter::MAX_CONCURRENT_STREAMS)); | |
253 EXPECT_EQ("MAX_CONCURRENT_STREAMS", Http2SettingsParameterToString(0x3)); | |
254 EXPECT_EQ("INITIAL_WINDOW_SIZE", | |
255 Http2SettingsParameterToString( | |
256 Http2SettingsParameter::INITIAL_WINDOW_SIZE)); | |
257 EXPECT_EQ("INITIAL_WINDOW_SIZE", Http2SettingsParameterToString(0x4)); | |
258 EXPECT_EQ("MAX_FRAME_SIZE", Http2SettingsParameterToString( | |
259 Http2SettingsParameter::MAX_FRAME_SIZE)); | |
260 EXPECT_EQ("MAX_FRAME_SIZE", Http2SettingsParameterToString(0x5)); | |
261 EXPECT_EQ("MAX_HEADER_LIST_SIZE", | |
262 Http2SettingsParameterToString( | |
263 Http2SettingsParameter::MAX_HEADER_LIST_SIZE)); | |
264 EXPECT_EQ("MAX_HEADER_LIST_SIZE", Http2SettingsParameterToString(0x6)); | |
265 | |
266 EXPECT_EQ("UnknownSettingsParameter(0x123)", | |
267 Http2SettingsParameterToString(0x123)); | |
268 } | |
269 | |
270 } // namespace | |
271 } // namespace test | |
272 } // namespace net | |
OLD | NEW |