1 // Copyright 2024 gRPC authors.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include "src/core/ext/transport/chttp2/transport/http2_settings.h"
16
17 #include "gmock/gmock.h"
18 #include "gtest/gtest.h"
19
20 namespace grpc_core {
21
TEST(Http2SettingsTest,CanSetAndRetrieveSettings)22 TEST(Http2SettingsTest, CanSetAndRetrieveSettings) {
23 Http2Settings settings;
24 settings.SetHeaderTableSize(1);
25 settings.SetEnablePush(true);
26 settings.SetMaxConcurrentStreams(3);
27 settings.SetInitialWindowSize(4);
28 settings.SetMaxFrameSize(50000);
29 settings.SetMaxHeaderListSize(6);
30 settings.SetAllowTrueBinaryMetadata(true);
31 settings.SetPreferredReceiveCryptoMessageSize(77777);
32 EXPECT_EQ(settings.header_table_size(), 1u);
33 EXPECT_EQ(settings.enable_push(), true);
34 EXPECT_EQ(settings.max_concurrent_streams(), 3u);
35 EXPECT_EQ(settings.initial_window_size(), 4u);
36 EXPECT_EQ(settings.max_frame_size(), 50000u);
37 EXPECT_EQ(settings.max_header_list_size(), 6u);
38 EXPECT_EQ(settings.allow_true_binary_metadata(), true);
39 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 77777u);
40 settings.SetHeaderTableSize(10);
41 settings.SetEnablePush(false);
42 settings.SetMaxConcurrentStreams(30);
43 settings.SetInitialWindowSize(40);
44 settings.SetMaxFrameSize(5000000);
45 settings.SetMaxHeaderListSize(60);
46 settings.SetAllowTrueBinaryMetadata(false);
47 settings.SetPreferredReceiveCryptoMessageSize(70000);
48 EXPECT_EQ(settings.header_table_size(), 10u);
49 EXPECT_EQ(settings.enable_push(), false);
50 EXPECT_EQ(settings.max_concurrent_streams(), 30u);
51 EXPECT_EQ(settings.initial_window_size(), 40u);
52 EXPECT_EQ(settings.max_frame_size(), 5000000u);
53 EXPECT_EQ(settings.max_header_list_size(), 60u);
54 EXPECT_EQ(settings.allow_true_binary_metadata(), false);
55 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 70000u);
56 }
57
TEST(Http2SettingsTest,InitialWindowSizeLimits)58 TEST(Http2SettingsTest, InitialWindowSizeLimits) {
59 Http2Settings settings;
60 settings.SetInitialWindowSize(0);
61 EXPECT_EQ(settings.initial_window_size(), 0u);
62 settings.SetInitialWindowSize(0x7fffffff);
63 EXPECT_EQ(settings.initial_window_size(), 0x7fffffffu);
64 settings.SetInitialWindowSize(0x80000000);
65 EXPECT_EQ(settings.initial_window_size(), 0x7fffffffu);
66 settings.SetInitialWindowSize(0xffffffff);
67 EXPECT_EQ(settings.initial_window_size(), 0x7fffffffu);
68 }
69
TEST(Http2SettingsTest,MaxFrameSizeLimits)70 TEST(Http2SettingsTest, MaxFrameSizeLimits) {
71 Http2Settings settings;
72 settings.SetMaxFrameSize(0);
73 EXPECT_EQ(settings.max_frame_size(), 16384u);
74 settings.SetMaxFrameSize(16384);
75 EXPECT_EQ(settings.max_frame_size(), 16384u);
76 settings.SetMaxFrameSize(16385);
77 EXPECT_EQ(settings.max_frame_size(), 16385u);
78 settings.SetMaxFrameSize(16777215);
79 EXPECT_EQ(settings.max_frame_size(), 16777215u);
80 settings.SetMaxFrameSize(16777216);
81 EXPECT_EQ(settings.max_frame_size(), 16777215u);
82 settings.SetMaxFrameSize(16777217);
83 EXPECT_EQ(settings.max_frame_size(), 16777215u);
84 settings.SetMaxFrameSize(0xffffffff);
85 EXPECT_EQ(settings.max_frame_size(), 16777215u);
86 }
87
TEST(Http2SettingsTest,PreferredReceiveCryptoMessageSize)88 TEST(Http2SettingsTest, PreferredReceiveCryptoMessageSize) {
89 Http2Settings settings;
90 settings.SetPreferredReceiveCryptoMessageSize(0);
91 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 16384u);
92 settings.SetPreferredReceiveCryptoMessageSize(16384);
93 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 16384u);
94 settings.SetPreferredReceiveCryptoMessageSize(16385);
95 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 16385u);
96 settings.SetPreferredReceiveCryptoMessageSize(16777215);
97 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 16777215u);
98 settings.SetPreferredReceiveCryptoMessageSize(16777216);
99 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 16777216u);
100 settings.SetPreferredReceiveCryptoMessageSize(16777217);
101 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 16777217u);
102 settings.SetPreferredReceiveCryptoMessageSize(0x7fffffff);
103 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 0x7fffffffu);
104 settings.SetPreferredReceiveCryptoMessageSize(0x80000000);
105 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 0x7fffffffu);
106 settings.SetPreferredReceiveCryptoMessageSize(0xffffffff);
107 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 0x7fffffffu);
108 }
109
110 namespace {
111 using KeyValue = std::pair<uint16_t, uint32_t>;
112 using KeyValueVec = std::vector<KeyValue>;
113
Diff(const Http2Settings & a,const Http2Settings & b,bool is_first_send)114 KeyValueVec Diff(const Http2Settings& a, const Http2Settings& b,
115 bool is_first_send) {
116 KeyValueVec diffs;
117 a.Diff(is_first_send, b, [&diffs](uint16_t key, uint32_t value) {
118 diffs.emplace_back(key, value);
119 });
120 return diffs;
121 }
122
operator ==(const KeyValue & a,const Http2SettingsFrame::Setting & b)123 bool operator==(const KeyValue& a, const Http2SettingsFrame::Setting& b) {
124 return a.first == b.id && a.second == b.value;
125 }
126
127 } // namespace
128
TEST(Http2SettingsTest,DiffOnFreshlyInitializedSettings)129 TEST(Http2SettingsTest, DiffOnFreshlyInitializedSettings) {
130 const Http2Settings settings1;
131 const Http2Settings settings2;
132 EXPECT_THAT(Diff(settings1, settings2, false), ::testing::IsEmpty());
133 EXPECT_THAT(Diff(settings1, settings2, true),
134 ::testing::UnorderedElementsAre(KeyValue{4, 65535}));
135 }
136
TEST(Http2SettingsTest,DiffOnSettingsWithOneValueSet)137 TEST(Http2SettingsTest, DiffOnSettingsWithOneValueSet) {
138 Http2Settings settings1;
139 Http2Settings settings2;
140 settings1.SetHeaderTableSize(1);
141 EXPECT_THAT(Diff(settings1, settings2, false),
142 ::testing::UnorderedElementsAre(KeyValue{1, 1}));
143 EXPECT_THAT(
144 Diff(settings1, settings2, true),
145 ::testing::UnorderedElementsAre(KeyValue{1, 1}, KeyValue{4, 65535}));
146 }
147
TEST(Http2SettingsTest,DiffOnSettingsWithTwoValuesSet)148 TEST(Http2SettingsTest, DiffOnSettingsWithTwoValuesSet) {
149 Http2Settings settings1;
150 Http2Settings settings2;
151 settings1.SetHeaderTableSize(1);
152 settings1.SetEnablePush(false);
153 EXPECT_THAT(Diff(settings1, settings2, false),
154 ::testing::UnorderedElementsAre(KeyValue{1, 1}, KeyValue{2, 0}));
155 EXPECT_THAT(Diff(settings1, settings2, true),
156 ::testing::UnorderedElementsAre(KeyValue{1, 1}, KeyValue{2, 0},
157 KeyValue{4, 65535}));
158 }
159
TEST(Http2SettingsTest,DiffOnSettingsWithThreeValuesSet)160 TEST(Http2SettingsTest, DiffOnSettingsWithThreeValuesSet) {
161 Http2Settings settings1;
162 Http2Settings settings2;
163 settings1.SetHeaderTableSize(1);
164 settings1.SetEnablePush(false);
165 settings1.SetMaxConcurrentStreams(3);
166 EXPECT_THAT(Diff(settings1, settings2, false),
167 ::testing::UnorderedElementsAre(KeyValue{1, 1}, KeyValue{2, 0},
168 KeyValue{3, 3}));
169 EXPECT_THAT(
170 Diff(settings1, settings2, true),
171 ::testing::UnorderedElementsAre(KeyValue{1, 1}, KeyValue{2, 0},
172 KeyValue{3, 3}, KeyValue{4, 65535}));
173 }
174
TEST(Http2SettingsTest,DiffOnSettingsWithFourValuesSet)175 TEST(Http2SettingsTest, DiffOnSettingsWithFourValuesSet) {
176 Http2Settings settings1;
177 Http2Settings settings2;
178 settings1.SetHeaderTableSize(1);
179 settings1.SetEnablePush(false);
180 settings1.SetMaxConcurrentStreams(3);
181 settings1.SetInitialWindowSize(4);
182 EXPECT_THAT(Diff(settings1, settings2, false),
183 ::testing::UnorderedElementsAre(KeyValue{1, 1}, KeyValue{2, 0},
184 KeyValue{3, 3}, KeyValue{4, 4}));
185 EXPECT_THAT(Diff(settings1, settings2, true),
186 ::testing::UnorderedElementsAre(KeyValue{1, 1}, KeyValue{2, 0},
187 KeyValue{3, 3}, KeyValue{4, 4}));
188 }
189
TEST(Http2SettingsTest,DiffOnSettingsWithFiveValuesSet)190 TEST(Http2SettingsTest, DiffOnSettingsWithFiveValuesSet) {
191 Http2Settings settings1;
192 Http2Settings settings2;
193 settings1.SetHeaderTableSize(1);
194 settings1.SetEnablePush(false);
195 settings1.SetMaxConcurrentStreams(3);
196 settings1.SetInitialWindowSize(4);
197 settings1.SetMaxFrameSize(50000);
198 EXPECT_THAT(Diff(settings1, settings2, false),
199 ::testing::UnorderedElementsAre(KeyValue{1, 1}, KeyValue{2, 0},
200 KeyValue{3, 3}, KeyValue{4, 4},
201 KeyValue{5, 50000}));
202 EXPECT_THAT(Diff(settings1, settings2, true),
203 ::testing::UnorderedElementsAre(KeyValue{1, 1}, KeyValue{2, 0},
204 KeyValue{3, 3}, KeyValue{4, 4},
205 KeyValue{5, 50000}));
206 }
207
TEST(Http2SettingsTest,DiffOnSettingsWithSixValuesSet)208 TEST(Http2SettingsTest, DiffOnSettingsWithSixValuesSet) {
209 Http2Settings settings1;
210 Http2Settings settings2;
211 settings1.SetHeaderTableSize(1);
212 settings1.SetEnablePush(false);
213 settings1.SetMaxConcurrentStreams(3);
214 settings1.SetInitialWindowSize(4);
215 settings1.SetMaxFrameSize(50000);
216 settings1.SetMaxHeaderListSize(6);
217 EXPECT_THAT(Diff(settings1, settings2, false),
218 ::testing::UnorderedElementsAre(
219 KeyValue{1, 1}, KeyValue{2, 0}, KeyValue{3, 3},
220 KeyValue{4, 4}, KeyValue{5, 50000}, KeyValue{6, 6}));
221 EXPECT_THAT(Diff(settings1, settings2, true),
222 ::testing::UnorderedElementsAre(
223 KeyValue{1, 1}, KeyValue{2, 0}, KeyValue{3, 3},
224 KeyValue{4, 4}, KeyValue{5, 50000}, KeyValue{6, 6}));
225 }
226
TEST(Http2SettingsTest,DiffOnSettingsWithSevenValuesSet)227 TEST(Http2SettingsTest, DiffOnSettingsWithSevenValuesSet) {
228 Http2Settings settings1;
229 Http2Settings settings2;
230 settings1.SetHeaderTableSize(1);
231 settings1.SetEnablePush(false);
232 settings1.SetMaxConcurrentStreams(3);
233 settings1.SetInitialWindowSize(4);
234 settings1.SetMaxFrameSize(50000);
235 settings1.SetMaxHeaderListSize(6);
236 settings1.SetAllowTrueBinaryMetadata(true);
237 EXPECT_THAT(
238 Diff(settings1, settings2, false),
239 ::testing::UnorderedElementsAre(
240 KeyValue{1, 1}, KeyValue{2, 0}, KeyValue{3, 3}, KeyValue{4, 4},
241 KeyValue{5, 50000}, KeyValue{6, 6}, KeyValue{65027, 1}));
242 EXPECT_THAT(
243 Diff(settings1, settings2, true),
244 ::testing::UnorderedElementsAre(
245 KeyValue{1, 1}, KeyValue{2, 0}, KeyValue{3, 3}, KeyValue{4, 4},
246 KeyValue{5, 50000}, KeyValue{6, 6}, KeyValue{65027, 1}));
247 }
248
TEST(Http2SettingsTest,DiffOnSettingsWithEightValuesSet)249 TEST(Http2SettingsTest, DiffOnSettingsWithEightValuesSet) {
250 Http2Settings settings1;
251 Http2Settings settings2;
252 settings1.SetHeaderTableSize(1);
253 settings1.SetEnablePush(false);
254 settings1.SetMaxConcurrentStreams(3);
255 settings1.SetInitialWindowSize(4);
256 settings1.SetMaxFrameSize(50000);
257 settings1.SetMaxHeaderListSize(6);
258 settings1.SetAllowTrueBinaryMetadata(true);
259 settings1.SetPreferredReceiveCryptoMessageSize(77777);
260 EXPECT_THAT(Diff(settings1, settings2, false),
261 ::testing::UnorderedElementsAre(
262 KeyValue{1, 1}, KeyValue{2, 0}, KeyValue{3, 3},
263 KeyValue{4, 4}, KeyValue{5, 50000}, KeyValue{6, 6},
264 KeyValue{65027, 1}, KeyValue{65028, 77777}));
265 EXPECT_THAT(Diff(settings1, settings2, true),
266 ::testing::UnorderedElementsAre(
267 KeyValue{1, 1}, KeyValue{2, 0}, KeyValue{3, 3},
268 KeyValue{4, 4}, KeyValue{5, 50000}, KeyValue{6, 6},
269 KeyValue{65027, 1}, KeyValue{65028, 77777}));
270 }
271
TEST(Http2SettingsTest,ChangingHeaderTableSizeChangesEquality)272 TEST(Http2SettingsTest, ChangingHeaderTableSizeChangesEquality) {
273 Http2Settings settings1;
274 Http2Settings settings2;
275 settings1.SetHeaderTableSize(1);
276 EXPECT_NE(settings1, settings2);
277 settings2.SetHeaderTableSize(1);
278 EXPECT_EQ(settings1, settings2);
279 settings2.SetHeaderTableSize(2);
280 EXPECT_NE(settings1, settings2);
281 }
282
TEST(Http2SettingsTest,ChangingEnablePushChangesEquality)283 TEST(Http2SettingsTest, ChangingEnablePushChangesEquality) {
284 Http2Settings settings1;
285 Http2Settings settings2;
286 settings1.SetEnablePush(false);
287 EXPECT_NE(settings1, settings2);
288 settings2.SetEnablePush(false);
289 EXPECT_EQ(settings1, settings2);
290 settings2.SetEnablePush(true);
291 EXPECT_NE(settings1, settings2);
292 }
293
TEST(Http2SettingsTest,ChangingMaxConcurrentStreamsChangesEquality)294 TEST(Http2SettingsTest, ChangingMaxConcurrentStreamsChangesEquality) {
295 Http2Settings settings1;
296 Http2Settings settings2;
297 settings1.SetMaxConcurrentStreams(1);
298 EXPECT_NE(settings1, settings2);
299 settings2.SetMaxConcurrentStreams(1);
300 EXPECT_EQ(settings1, settings2);
301 settings2.SetMaxConcurrentStreams(2);
302 EXPECT_NE(settings1, settings2);
303 }
304
TEST(Http2SettingsTest,ChangingInitialWindowSizeChangesEquality)305 TEST(Http2SettingsTest, ChangingInitialWindowSizeChangesEquality) {
306 Http2Settings settings1;
307 Http2Settings settings2;
308 settings1.SetInitialWindowSize(1);
309 EXPECT_NE(settings1, settings2);
310 settings2.SetInitialWindowSize(1);
311 EXPECT_EQ(settings1, settings2);
312 settings2.SetInitialWindowSize(2);
313 EXPECT_NE(settings1, settings2);
314 }
315
TEST(Http2SettingsTest,ChangingMaxFrameSizeChangesEquality)316 TEST(Http2SettingsTest, ChangingMaxFrameSizeChangesEquality) {
317 Http2Settings settings1;
318 Http2Settings settings2;
319 settings1.SetMaxFrameSize(100000);
320 EXPECT_NE(settings1, settings2);
321 settings2.SetMaxFrameSize(100000);
322 EXPECT_EQ(settings1, settings2);
323 settings2.SetMaxFrameSize(200000);
324 EXPECT_NE(settings1, settings2);
325 }
326
TEST(Http2SettingsTest,ChangingMaxHeaderListSizeChangesEquality)327 TEST(Http2SettingsTest, ChangingMaxHeaderListSizeChangesEquality) {
328 Http2Settings settings1;
329 Http2Settings settings2;
330 settings1.SetMaxHeaderListSize(1);
331 EXPECT_NE(settings1, settings2);
332 settings2.SetMaxHeaderListSize(1);
333 EXPECT_EQ(settings1, settings2);
334 settings2.SetMaxHeaderListSize(2);
335 EXPECT_NE(settings1, settings2);
336 }
337
TEST(Http2SettingsTest,ChangingAllowTrueBinaryMetadataChangesEquality)338 TEST(Http2SettingsTest, ChangingAllowTrueBinaryMetadataChangesEquality) {
339 Http2Settings settings1;
340 Http2Settings settings2;
341 settings1.SetAllowTrueBinaryMetadata(true);
342 EXPECT_NE(settings1, settings2);
343 settings2.SetAllowTrueBinaryMetadata(true);
344 EXPECT_EQ(settings1, settings2);
345 settings2.SetAllowTrueBinaryMetadata(false);
346 EXPECT_NE(settings1, settings2);
347 }
348
TEST(Http2SettingsTest,ChangingPreferredReceiveCryptoMessageSizeChangesEquality)349 TEST(Http2SettingsTest,
350 ChangingPreferredReceiveCryptoMessageSizeChangesEquality) {
351 Http2Settings settings1;
352 Http2Settings settings2;
353 settings1.SetPreferredReceiveCryptoMessageSize(100000);
354 EXPECT_NE(settings1, settings2);
355 settings2.SetPreferredReceiveCryptoMessageSize(100000);
356 EXPECT_EQ(settings1, settings2);
357 settings2.SetPreferredReceiveCryptoMessageSize(200000);
358 EXPECT_NE(settings1, settings2);
359 }
360
TEST(Http2SettingsTest,WireIdToNameWorks)361 TEST(Http2SettingsTest, WireIdToNameWorks) {
362 EXPECT_EQ(Http2Settings::WireIdToName(1), "HEADER_TABLE_SIZE");
363 EXPECT_EQ(Http2Settings::WireIdToName(2), "ENABLE_PUSH");
364 EXPECT_EQ(Http2Settings::WireIdToName(3), "MAX_CONCURRENT_STREAMS");
365 EXPECT_EQ(Http2Settings::WireIdToName(4), "INITIAL_WINDOW_SIZE");
366 EXPECT_EQ(Http2Settings::WireIdToName(5), "MAX_FRAME_SIZE");
367 EXPECT_EQ(Http2Settings::WireIdToName(6), "MAX_HEADER_LIST_SIZE");
368 EXPECT_EQ(Http2Settings::WireIdToName(65027),
369 "GRPC_ALLOW_TRUE_BINARY_METADATA");
370 EXPECT_EQ(Http2Settings::WireIdToName(65028),
371 "GRPC_PREFERRED_RECEIVE_MESSAGE_SIZE");
372 EXPECT_EQ(Http2Settings::WireIdToName(65029), "UNKNOWN (65029)");
373 }
374
TEST(Http2SettingsTest,ApplyHeaderTableSizeWorks)375 TEST(Http2SettingsTest, ApplyHeaderTableSizeWorks) {
376 Http2Settings settings;
377 EXPECT_EQ(settings.Apply(1, 1), GRPC_HTTP2_NO_ERROR);
378 EXPECT_EQ(settings.header_table_size(), 1u);
379 EXPECT_EQ(settings.Apply(1, 0x7fffffff), GRPC_HTTP2_NO_ERROR);
380 EXPECT_EQ(settings.header_table_size(), 0x7fffffffu);
381 }
382
TEST(Http2SettingsTest,ApplyEnablePushWorks)383 TEST(Http2SettingsTest, ApplyEnablePushWorks) {
384 Http2Settings settings;
385 EXPECT_EQ(settings.Apply(2, 0), GRPC_HTTP2_NO_ERROR);
386 EXPECT_EQ(settings.enable_push(), false);
387 EXPECT_EQ(settings.Apply(2, 1), GRPC_HTTP2_NO_ERROR);
388 EXPECT_EQ(settings.enable_push(), true);
389 EXPECT_EQ(settings.Apply(2, 2), GRPC_HTTP2_PROTOCOL_ERROR);
390 }
391
TEST(Http2SettingsTest,ApplyMaxConcurrentStreamsWorks)392 TEST(Http2SettingsTest, ApplyMaxConcurrentStreamsWorks) {
393 Http2Settings settings;
394 EXPECT_EQ(settings.Apply(3, 1), GRPC_HTTP2_NO_ERROR);
395 EXPECT_EQ(settings.max_concurrent_streams(), 1u);
396 EXPECT_EQ(settings.Apply(3, 0x7fffffff), GRPC_HTTP2_NO_ERROR);
397 EXPECT_EQ(settings.max_concurrent_streams(), 0x7fffffffu);
398 }
399
TEST(Http2SettingsTest,ApplyInitialWindowSizeWorks)400 TEST(Http2SettingsTest, ApplyInitialWindowSizeWorks) {
401 Http2Settings settings;
402 EXPECT_EQ(settings.Apply(4, 1), GRPC_HTTP2_NO_ERROR);
403 EXPECT_EQ(settings.initial_window_size(), 1u);
404 EXPECT_EQ(settings.Apply(4, 0x7fffffff), GRPC_HTTP2_NO_ERROR);
405 EXPECT_EQ(settings.initial_window_size(), 0x7fffffffu);
406 }
407
TEST(Http2SettingsTest,ApplyMaxFrameSizeWorks)408 TEST(Http2SettingsTest, ApplyMaxFrameSizeWorks) {
409 Http2Settings settings;
410 EXPECT_EQ(settings.Apply(5, 16384), GRPC_HTTP2_NO_ERROR);
411 EXPECT_EQ(settings.max_frame_size(), 16384u);
412 EXPECT_EQ(settings.Apply(5, 16777215), GRPC_HTTP2_NO_ERROR);
413 EXPECT_EQ(settings.max_frame_size(), 16777215);
414 EXPECT_EQ(settings.Apply(5, 16383), GRPC_HTTP2_PROTOCOL_ERROR);
415 EXPECT_EQ(settings.Apply(5, 16777216), GRPC_HTTP2_PROTOCOL_ERROR);
416 }
417
TEST(Http2SettingsTest,ApplyMaxHeaderListSizeWorks)418 TEST(Http2SettingsTest, ApplyMaxHeaderListSizeWorks) {
419 Http2Settings settings;
420 EXPECT_EQ(settings.Apply(6, 1), GRPC_HTTP2_NO_ERROR);
421 EXPECT_EQ(settings.max_header_list_size(), 1u);
422 EXPECT_EQ(settings.Apply(6, 0x7fffffff), GRPC_HTTP2_NO_ERROR);
423 EXPECT_EQ(settings.max_header_list_size(), 16777216);
424 }
425
TEST(Http2SettingsTest,ApplyAllowTrueBinaryMetadataWorks)426 TEST(Http2SettingsTest, ApplyAllowTrueBinaryMetadataWorks) {
427 Http2Settings settings;
428 EXPECT_EQ(settings.Apply(65027, 0), GRPC_HTTP2_NO_ERROR);
429 EXPECT_EQ(settings.allow_true_binary_metadata(), false);
430 EXPECT_EQ(settings.Apply(65027, 1), GRPC_HTTP2_NO_ERROR);
431 EXPECT_EQ(settings.allow_true_binary_metadata(), true);
432 EXPECT_EQ(settings.Apply(65027, 2), GRPC_HTTP2_PROTOCOL_ERROR);
433 }
434
TEST(Http2SettingsTest,ApplyPreferredReceiveCryptoMessageSizeWorks)435 TEST(Http2SettingsTest, ApplyPreferredReceiveCryptoMessageSizeWorks) {
436 Http2Settings settings;
437 EXPECT_EQ(settings.Apply(65028, 1), GRPC_HTTP2_NO_ERROR);
438 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 16384u);
439 EXPECT_EQ(settings.Apply(65028, 0x7fffffff), GRPC_HTTP2_NO_ERROR);
440 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 0x7fffffffu);
441 EXPECT_EQ(settings.Apply(65028, 0x80000000), GRPC_HTTP2_NO_ERROR);
442 EXPECT_EQ(settings.preferred_receive_crypto_message_size(), 0x7fffffffu);
443 }
444
445 namespace {
446 MATCHER_P(SettingsFrame, settings, "") {
447 if (!arg.has_value()) {
448 *result_listener << "Expected a settings frame, got nothing";
449 return false;
450 }
451 if (arg->ack) {
452 *result_listener << "Expected a settings frame, got an ack";
453 return false;
454 }
455 if (arg->settings.size() != settings.size()) {
456 *result_listener << "Expected settings frame with " << settings.size()
457 << " settings, got " << arg->settings.size();
458 return false;
459 }
460 for (size_t i = 0; i < settings.size(); i++) {
461 bool found = false;
462 for (size_t j = 0; j < arg->settings.size(); j++) {
463 if (settings[i] == arg->settings[j]) {
464 found = true;
465 break;
466 }
467 }
468 if (!found) {
469 *result_listener << "Expected settings frame with setting "
470 << settings[i].first << " = " << settings[i].second
471 << ", but it was not found";
472 return false;
473 }
474 }
475 return true;
476 }
477 } // namespace
478
TEST(Http2SettingsManagerTest,ImmediatelyNeedsToSend)479 TEST(Http2SettingsManagerTest, ImmediatelyNeedsToSend) {
480 Http2SettingsManager settings_manager;
481 EXPECT_THAT(settings_manager.MaybeSendUpdate(),
482 SettingsFrame(KeyValueVec{{4, 65535}}));
483 }
484
TEST(Http2SettingsManagerTest,SendAckWorks)485 TEST(Http2SettingsManagerTest, SendAckWorks) {
486 Http2SettingsManager settings_manager;
487 settings_manager.mutable_local().SetInitialWindowSize(100000);
488 EXPECT_EQ(settings_manager.acked().initial_window_size(), 65535u);
489 EXPECT_THAT(settings_manager.MaybeSendUpdate(),
490 SettingsFrame(KeyValueVec{{4, 100000}}));
491 EXPECT_TRUE(settings_manager.AckLastSend());
492 EXPECT_EQ(settings_manager.acked().initial_window_size(), 100000u);
493 }
494
TEST(Http2SettingsManagerTest,AckWithoutSendFails)495 TEST(Http2SettingsManagerTest, AckWithoutSendFails) {
496 Http2SettingsManager settings_manager;
497 EXPECT_FALSE(settings_manager.AckLastSend());
498 }
499
TEST(Http2SettingsManagerTest,AckAfterAckFails)500 TEST(Http2SettingsManagerTest, AckAfterAckFails) {
501 Http2SettingsManager settings_manager;
502 settings_manager.mutable_local().SetInitialWindowSize(100000);
503 EXPECT_THAT(settings_manager.MaybeSendUpdate(),
504 SettingsFrame(KeyValueVec{{4, 100000}}));
505 EXPECT_TRUE(settings_manager.AckLastSend());
506 EXPECT_FALSE(settings_manager.AckLastSend());
507 }
508
509 } // namespace grpc_core
510
main(int argc,char ** argv)511 int main(int argc, char** argv) {
512 ::testing::InitGoogleTest(&argc, argv);
513 return RUN_ALL_TESTS();
514 }
515