1 // Copyright (c) 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 "quiche/quic/core/frames/quic_ack_frame.h"
6 #include "quiche/quic/core/frames/quic_blocked_frame.h"
7 #include "quiche/quic/core/frames/quic_connection_close_frame.h"
8 #include "quiche/quic/core/frames/quic_frame.h"
9 #include "quiche/quic/core/frames/quic_goaway_frame.h"
10 #include "quiche/quic/core/frames/quic_mtu_discovery_frame.h"
11 #include "quiche/quic/core/frames/quic_new_connection_id_frame.h"
12 #include "quiche/quic/core/frames/quic_padding_frame.h"
13 #include "quiche/quic/core/frames/quic_ping_frame.h"
14 #include "quiche/quic/core/frames/quic_rst_stream_frame.h"
15 #include "quiche/quic/core/frames/quic_stop_waiting_frame.h"
16 #include "quiche/quic/core/frames/quic_stream_frame.h"
17 #include "quiche/quic/core/frames/quic_window_update_frame.h"
18 #include "quiche/quic/core/quic_interval.h"
19 #include "quiche/quic/core/quic_types.h"
20 #include "quiche/quic/platform/api/quic_expect_bug.h"
21 #include "quiche/quic/platform/api/quic_test.h"
22 #include "quiche/quic/test_tools/quic_test_utils.h"
23
24 namespace quic {
25 namespace test {
26 namespace {
27
28 class QuicFramesTest : public QuicTest {};
29
TEST_F(QuicFramesTest,AckFrameToString)30 TEST_F(QuicFramesTest, AckFrameToString) {
31 QuicAckFrame frame;
32 frame.largest_acked = QuicPacketNumber(5);
33 frame.ack_delay_time = QuicTime::Delta::FromMicroseconds(3);
34 frame.packets.Add(QuicPacketNumber(4));
35 frame.packets.Add(QuicPacketNumber(5));
36 frame.received_packet_times = {
37 {QuicPacketNumber(6),
38 QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(7)}};
39 std::ostringstream stream;
40 stream << frame;
41 EXPECT_EQ(
42 "{ largest_acked: 5, ack_delay_time: 3, packets: [ 4 5 ], "
43 "received_packets: [ 6 at 7 ], ecn_counters_populated: 0 }\n",
44 stream.str());
45 QuicFrame quic_frame(&frame);
46 EXPECT_FALSE(IsControlFrame(quic_frame.type));
47 }
48
TEST_F(QuicFramesTest,BigAckFrameToString)49 TEST_F(QuicFramesTest, BigAckFrameToString) {
50 QuicAckFrame frame;
51 frame.largest_acked = QuicPacketNumber(500);
52 frame.ack_delay_time = QuicTime::Delta::FromMicroseconds(3);
53 frame.packets.AddRange(QuicPacketNumber(4), QuicPacketNumber(501));
54 frame.received_packet_times = {
55 {QuicPacketNumber(500),
56 QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(7)}};
57 std::ostringstream stream;
58 stream << frame;
59 EXPECT_EQ(
60 "{ largest_acked: 500, ack_delay_time: 3, packets: [ 4...500 ], "
61 "received_packets: [ 500 at 7 ], ecn_counters_populated: 0 }\n",
62 stream.str());
63 QuicFrame quic_frame(&frame);
64 EXPECT_FALSE(IsControlFrame(quic_frame.type));
65 }
66
TEST_F(QuicFramesTest,PaddingFrameToString)67 TEST_F(QuicFramesTest, PaddingFrameToString) {
68 QuicPaddingFrame frame;
69 frame.num_padding_bytes = 1;
70 std::ostringstream stream;
71 stream << frame;
72 EXPECT_EQ("{ num_padding_bytes: 1 }\n", stream.str());
73 QuicFrame quic_frame(frame);
74 EXPECT_FALSE(IsControlFrame(quic_frame.type));
75 }
76
TEST_F(QuicFramesTest,RstStreamFrameToString)77 TEST_F(QuicFramesTest, RstStreamFrameToString) {
78 QuicRstStreamFrame rst_stream;
79 QuicFrame frame(&rst_stream);
80 SetControlFrameId(1, &frame);
81 EXPECT_EQ(1u, GetControlFrameId(frame));
82 rst_stream.stream_id = 1;
83 rst_stream.byte_offset = 3;
84 rst_stream.error_code = QUIC_STREAM_CANCELLED;
85 std::ostringstream stream;
86 stream << rst_stream;
87 EXPECT_EQ(
88 "{ control_frame_id: 1, stream_id: 1, byte_offset: 3, error_code: 6, "
89 "ietf_error_code: 0 }\n",
90 stream.str());
91 EXPECT_TRUE(IsControlFrame(frame.type));
92 }
93
TEST_F(QuicFramesTest,StopSendingFrameToString)94 TEST_F(QuicFramesTest, StopSendingFrameToString) {
95 QuicFrame frame((QuicStopSendingFrame()));
96 SetControlFrameId(1, &frame);
97 EXPECT_EQ(1u, GetControlFrameId(frame));
98 frame.stop_sending_frame.stream_id = 321;
99 frame.stop_sending_frame.error_code = QUIC_STREAM_CANCELLED;
100 frame.stop_sending_frame.ietf_error_code =
101 static_cast<uint64_t>(QuicHttp3ErrorCode::REQUEST_CANCELLED);
102 std::ostringstream stream;
103 stream << frame.stop_sending_frame;
104 EXPECT_EQ(
105 "{ control_frame_id: 1, stream_id: 321, error_code: 6, ietf_error_code: "
106 "268 }\n",
107 stream.str());
108 }
109
TEST_F(QuicFramesTest,NewConnectionIdFrameToString)110 TEST_F(QuicFramesTest, NewConnectionIdFrameToString) {
111 QuicNewConnectionIdFrame new_connection_id_frame;
112 QuicFrame frame(&new_connection_id_frame);
113 SetControlFrameId(1, &frame);
114 QuicFrame frame_copy = CopyRetransmittableControlFrame(frame);
115 EXPECT_EQ(1u, GetControlFrameId(frame_copy));
116 new_connection_id_frame.connection_id = TestConnectionId(2);
117 new_connection_id_frame.sequence_number = 2u;
118 new_connection_id_frame.retire_prior_to = 1u;
119 new_connection_id_frame.stateless_reset_token =
120 StatelessResetToken{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1};
121 std::ostringstream stream;
122 stream << new_connection_id_frame;
123 EXPECT_EQ(
124 "{ control_frame_id: 1, connection_id: 0000000000000002, "
125 "sequence_number: 2, retire_prior_to: 1 }\n",
126 stream.str());
127 EXPECT_TRUE(IsControlFrame(frame_copy.type));
128 DeleteFrame(&frame_copy);
129 }
130
TEST_F(QuicFramesTest,RetireConnectionIdFrameToString)131 TEST_F(QuicFramesTest, RetireConnectionIdFrameToString) {
132 QuicRetireConnectionIdFrame retire_connection_id_frame;
133 QuicFrame frame(&retire_connection_id_frame);
134 SetControlFrameId(1, &frame);
135 QuicFrame frame_copy = CopyRetransmittableControlFrame(frame);
136 EXPECT_EQ(1u, GetControlFrameId(frame_copy));
137 retire_connection_id_frame.sequence_number = 1u;
138 std::ostringstream stream;
139 stream << retire_connection_id_frame;
140 EXPECT_EQ("{ control_frame_id: 1, sequence_number: 1 }\n", stream.str());
141 EXPECT_TRUE(IsControlFrame(frame_copy.type));
142 DeleteFrame(&frame_copy);
143 }
144
TEST_F(QuicFramesTest,StreamsBlockedFrameToString)145 TEST_F(QuicFramesTest, StreamsBlockedFrameToString) {
146 QuicStreamsBlockedFrame streams_blocked;
147 QuicFrame frame(streams_blocked);
148 SetControlFrameId(1, &frame);
149 EXPECT_EQ(1u, GetControlFrameId(frame));
150 // QuicStreamsBlocked is copied into a QuicFrame (as opposed to putting a
151 // pointer to it into QuicFrame) so need to work with the copy in |frame| and
152 // not the original one, streams_blocked.
153 frame.streams_blocked_frame.stream_count = 321;
154 frame.streams_blocked_frame.unidirectional = false;
155 std::ostringstream stream;
156 stream << frame.streams_blocked_frame;
157 EXPECT_EQ("{ control_frame_id: 1, stream count: 321, bidirectional }\n",
158 stream.str());
159 EXPECT_TRUE(IsControlFrame(frame.type));
160 }
161
TEST_F(QuicFramesTest,MaxStreamsFrameToString)162 TEST_F(QuicFramesTest, MaxStreamsFrameToString) {
163 QuicMaxStreamsFrame max_streams;
164 QuicFrame frame(max_streams);
165 SetControlFrameId(1, &frame);
166 EXPECT_EQ(1u, GetControlFrameId(frame));
167 // QuicMaxStreams is copied into a QuicFrame (as opposed to putting a
168 // pointer to it into QuicFrame) so need to work with the copy in |frame| and
169 // not the original one, max_streams.
170 frame.max_streams_frame.stream_count = 321;
171 frame.max_streams_frame.unidirectional = true;
172 std::ostringstream stream;
173 stream << frame.max_streams_frame;
174 EXPECT_EQ("{ control_frame_id: 1, stream_count: 321, unidirectional }\n",
175 stream.str());
176 EXPECT_TRUE(IsControlFrame(frame.type));
177 }
178
TEST_F(QuicFramesTest,ConnectionCloseFrameToString)179 TEST_F(QuicFramesTest, ConnectionCloseFrameToString) {
180 QuicConnectionCloseFrame frame;
181 frame.quic_error_code = QUIC_NETWORK_IDLE_TIMEOUT;
182 frame.error_details = "No recent network activity.";
183 std::ostringstream stream;
184 stream << frame;
185 // Note that "extracted_error_code: 122" is QUIC_IETF_GQUIC_ERROR_MISSING,
186 // indicating that, in fact, no extended error code was available from the
187 // underlying frame.
188 EXPECT_EQ(
189 "{ Close type: GOOGLE_QUIC_CONNECTION_CLOSE, "
190 "quic_error_code: QUIC_NETWORK_IDLE_TIMEOUT, "
191 "error_details: 'No recent network activity.'}\n",
192 stream.str());
193 QuicFrame quic_frame(&frame);
194 EXPECT_FALSE(IsControlFrame(quic_frame.type));
195 }
196
TEST_F(QuicFramesTest,TransportConnectionCloseFrameToString)197 TEST_F(QuicFramesTest, TransportConnectionCloseFrameToString) {
198 QuicConnectionCloseFrame frame;
199 frame.close_type = IETF_QUIC_TRANSPORT_CONNECTION_CLOSE;
200 frame.wire_error_code = FINAL_SIZE_ERROR;
201 frame.quic_error_code = QUIC_NETWORK_IDLE_TIMEOUT;
202 frame.error_details = "No recent network activity.";
203 frame.transport_close_frame_type = IETF_STREAM;
204 std::ostringstream stream;
205 stream << frame;
206 EXPECT_EQ(
207 "{ Close type: IETF_QUIC_TRANSPORT_CONNECTION_CLOSE, "
208 "wire_error_code: FINAL_SIZE_ERROR, "
209 "quic_error_code: QUIC_NETWORK_IDLE_TIMEOUT, "
210 "error_details: 'No recent "
211 "network activity.', "
212 "frame_type: IETF_STREAM"
213 "}\n",
214 stream.str());
215 QuicFrame quic_frame(&frame);
216 EXPECT_FALSE(IsControlFrame(quic_frame.type));
217 }
218
TEST_F(QuicFramesTest,GoAwayFrameToString)219 TEST_F(QuicFramesTest, GoAwayFrameToString) {
220 QuicGoAwayFrame goaway_frame;
221 QuicFrame frame(&goaway_frame);
222 SetControlFrameId(2, &frame);
223 EXPECT_EQ(2u, GetControlFrameId(frame));
224 goaway_frame.error_code = QUIC_NETWORK_IDLE_TIMEOUT;
225 goaway_frame.last_good_stream_id = 2;
226 goaway_frame.reason_phrase = "Reason";
227 std::ostringstream stream;
228 stream << goaway_frame;
229 EXPECT_EQ(
230 "{ control_frame_id: 2, error_code: 25, last_good_stream_id: 2, "
231 "reason_phrase: "
232 "'Reason' }\n",
233 stream.str());
234 EXPECT_TRUE(IsControlFrame(frame.type));
235 }
236
TEST_F(QuicFramesTest,WindowUpdateFrameToString)237 TEST_F(QuicFramesTest, WindowUpdateFrameToString) {
238 QuicFrame frame((QuicWindowUpdateFrame()));
239 SetControlFrameId(3, &frame);
240 EXPECT_EQ(3u, GetControlFrameId(frame));
241 std::ostringstream stream;
242 frame.window_update_frame.stream_id = 1;
243 frame.window_update_frame.max_data = 2;
244 stream << frame.window_update_frame;
245 EXPECT_EQ("{ control_frame_id: 3, stream_id: 1, max_data: 2 }\n",
246 stream.str());
247 EXPECT_TRUE(IsControlFrame(frame.type));
248 }
249
TEST_F(QuicFramesTest,BlockedFrameToString)250 TEST_F(QuicFramesTest, BlockedFrameToString) {
251 QuicFrame frame((QuicBlockedFrame()));
252 SetControlFrameId(4, &frame);
253 EXPECT_EQ(4u, GetControlFrameId(frame));
254 frame.blocked_frame.stream_id = 1;
255 frame.blocked_frame.offset = 2;
256 std::ostringstream stream;
257 stream << frame.blocked_frame;
258 EXPECT_EQ("{ control_frame_id: 4, stream_id: 1, offset: 2 }\n", stream.str());
259 EXPECT_TRUE(IsControlFrame(frame.type));
260 }
261
TEST_F(QuicFramesTest,PingFrameToString)262 TEST_F(QuicFramesTest, PingFrameToString) {
263 QuicPingFrame ping;
264 QuicFrame frame(ping);
265 SetControlFrameId(5, &frame);
266 EXPECT_EQ(5u, GetControlFrameId(frame));
267 std::ostringstream stream;
268 stream << frame.ping_frame;
269 EXPECT_EQ("{ control_frame_id: 5 }\n", stream.str());
270 EXPECT_TRUE(IsControlFrame(frame.type));
271 }
272
TEST_F(QuicFramesTest,HandshakeDoneFrameToString)273 TEST_F(QuicFramesTest, HandshakeDoneFrameToString) {
274 QuicHandshakeDoneFrame handshake_done;
275 QuicFrame frame(handshake_done);
276 SetControlFrameId(6, &frame);
277 EXPECT_EQ(6u, GetControlFrameId(frame));
278 std::ostringstream stream;
279 stream << frame.handshake_done_frame;
280 EXPECT_EQ("{ control_frame_id: 6 }\n", stream.str());
281 EXPECT_TRUE(IsControlFrame(frame.type));
282 }
283
TEST_F(QuicFramesTest,QuicAckFreuqncyFrameToString)284 TEST_F(QuicFramesTest, QuicAckFreuqncyFrameToString) {
285 QuicAckFrequencyFrame ack_frequency_frame;
286 ack_frequency_frame.sequence_number = 1;
287 ack_frequency_frame.packet_tolerance = 2;
288 ack_frequency_frame.max_ack_delay = QuicTime::Delta::FromMilliseconds(25);
289 ack_frequency_frame.ignore_order = false;
290 QuicFrame frame(&ack_frequency_frame);
291 ASSERT_EQ(ACK_FREQUENCY_FRAME, frame.type);
292 SetControlFrameId(6, &frame);
293 EXPECT_EQ(6u, GetControlFrameId(frame));
294 std::ostringstream stream;
295 stream << *frame.ack_frequency_frame;
296 EXPECT_EQ(
297 "{ control_frame_id: 6, sequence_number: 1, packet_tolerance: 2, "
298 "max_ack_delay_ms: 25, ignore_order: 0 }\n",
299 stream.str());
300 EXPECT_TRUE(IsControlFrame(frame.type));
301 }
302
TEST_F(QuicFramesTest,StreamFrameToString)303 TEST_F(QuicFramesTest, StreamFrameToString) {
304 QuicStreamFrame frame;
305 frame.stream_id = 1;
306 frame.fin = false;
307 frame.offset = 2;
308 frame.data_length = 3;
309 std::ostringstream stream;
310 stream << frame;
311 EXPECT_EQ("{ stream_id: 1, fin: 0, offset: 2, length: 3 }\n", stream.str());
312 EXPECT_FALSE(IsControlFrame(frame.type));
313 }
314
TEST_F(QuicFramesTest,StopWaitingFrameToString)315 TEST_F(QuicFramesTest, StopWaitingFrameToString) {
316 QuicStopWaitingFrame frame;
317 frame.least_unacked = QuicPacketNumber(2);
318 std::ostringstream stream;
319 stream << frame;
320 EXPECT_EQ("{ least_unacked: 2 }\n", stream.str());
321 QuicFrame quic_frame(frame);
322 EXPECT_FALSE(IsControlFrame(quic_frame.type));
323 }
324
TEST_F(QuicFramesTest,IsAwaitingPacket)325 TEST_F(QuicFramesTest, IsAwaitingPacket) {
326 QuicAckFrame ack_frame1;
327 ack_frame1.largest_acked = QuicPacketNumber(10u);
328 ack_frame1.packets.AddRange(QuicPacketNumber(1), QuicPacketNumber(11));
329 EXPECT_TRUE(
330 IsAwaitingPacket(ack_frame1, QuicPacketNumber(11u), QuicPacketNumber()));
331 EXPECT_FALSE(
332 IsAwaitingPacket(ack_frame1, QuicPacketNumber(1u), QuicPacketNumber()));
333
334 ack_frame1.packets.Add(QuicPacketNumber(12));
335 EXPECT_TRUE(
336 IsAwaitingPacket(ack_frame1, QuicPacketNumber(11u), QuicPacketNumber()));
337
338 QuicAckFrame ack_frame2;
339 ack_frame2.largest_acked = QuicPacketNumber(100u);
340 ack_frame2.packets.AddRange(QuicPacketNumber(21), QuicPacketNumber(100));
341 EXPECT_FALSE(IsAwaitingPacket(ack_frame2, QuicPacketNumber(11u),
342 QuicPacketNumber(20u)));
343 EXPECT_FALSE(IsAwaitingPacket(ack_frame2, QuicPacketNumber(80u),
344 QuicPacketNumber(20u)));
345 EXPECT_TRUE(IsAwaitingPacket(ack_frame2, QuicPacketNumber(101u),
346 QuicPacketNumber(20u)));
347
348 ack_frame2.packets.AddRange(QuicPacketNumber(102), QuicPacketNumber(200));
349 EXPECT_TRUE(IsAwaitingPacket(ack_frame2, QuicPacketNumber(101u),
350 QuicPacketNumber(20u)));
351 }
352
TEST_F(QuicFramesTest,AddPacket)353 TEST_F(QuicFramesTest, AddPacket) {
354 QuicAckFrame ack_frame1;
355 ack_frame1.packets.Add(QuicPacketNumber(1));
356 ack_frame1.packets.Add(QuicPacketNumber(99));
357
358 EXPECT_EQ(2u, ack_frame1.packets.NumIntervals());
359 EXPECT_EQ(QuicPacketNumber(1u), ack_frame1.packets.Min());
360 EXPECT_EQ(QuicPacketNumber(99u), ack_frame1.packets.Max());
361
362 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals;
363 expected_intervals.emplace_back(
364 QuicInterval<QuicPacketNumber>(QuicPacketNumber(1), QuicPacketNumber(2)));
365 expected_intervals.emplace_back(QuicInterval<QuicPacketNumber>(
366 QuicPacketNumber(99), QuicPacketNumber(100)));
367
368 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals(
369 ack_frame1.packets.begin(), ack_frame1.packets.end());
370
371 EXPECT_EQ(expected_intervals, actual_intervals);
372
373 ack_frame1.packets.Add(QuicPacketNumber(20));
374 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals2(
375 ack_frame1.packets.begin(), ack_frame1.packets.end());
376
377 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals2;
378 expected_intervals2.emplace_back(
379 QuicInterval<QuicPacketNumber>(QuicPacketNumber(1), QuicPacketNumber(2)));
380 expected_intervals2.emplace_back(QuicInterval<QuicPacketNumber>(
381 QuicPacketNumber(20), QuicPacketNumber(21)));
382 expected_intervals2.emplace_back(QuicInterval<QuicPacketNumber>(
383 QuicPacketNumber(99), QuicPacketNumber(100)));
384
385 EXPECT_EQ(3u, ack_frame1.packets.NumIntervals());
386 EXPECT_EQ(expected_intervals2, actual_intervals2);
387
388 ack_frame1.packets.Add(QuicPacketNumber(19));
389 ack_frame1.packets.Add(QuicPacketNumber(21));
390
391 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals3(
392 ack_frame1.packets.begin(), ack_frame1.packets.end());
393
394 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals3;
395 expected_intervals3.emplace_back(
396 QuicInterval<QuicPacketNumber>(QuicPacketNumber(1), QuicPacketNumber(2)));
397 expected_intervals3.emplace_back(QuicInterval<QuicPacketNumber>(
398 QuicPacketNumber(19), QuicPacketNumber(22)));
399 expected_intervals3.emplace_back(QuicInterval<QuicPacketNumber>(
400 QuicPacketNumber(99), QuicPacketNumber(100)));
401
402 EXPECT_EQ(expected_intervals3, actual_intervals3);
403
404 ack_frame1.packets.Add(QuicPacketNumber(20));
405
406 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals4(
407 ack_frame1.packets.begin(), ack_frame1.packets.end());
408
409 EXPECT_EQ(expected_intervals3, actual_intervals4);
410
411 QuicAckFrame ack_frame2;
412 ack_frame2.packets.Add(QuicPacketNumber(20));
413 ack_frame2.packets.Add(QuicPacketNumber(40));
414 ack_frame2.packets.Add(QuicPacketNumber(60));
415 ack_frame2.packets.Add(QuicPacketNumber(10));
416 ack_frame2.packets.Add(QuicPacketNumber(80));
417
418 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals5(
419 ack_frame2.packets.begin(), ack_frame2.packets.end());
420
421 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals5;
422 expected_intervals5.emplace_back(QuicInterval<QuicPacketNumber>(
423 QuicPacketNumber(10), QuicPacketNumber(11)));
424 expected_intervals5.emplace_back(QuicInterval<QuicPacketNumber>(
425 QuicPacketNumber(20), QuicPacketNumber(21)));
426 expected_intervals5.emplace_back(QuicInterval<QuicPacketNumber>(
427 QuicPacketNumber(40), QuicPacketNumber(41)));
428 expected_intervals5.emplace_back(QuicInterval<QuicPacketNumber>(
429 QuicPacketNumber(60), QuicPacketNumber(61)));
430 expected_intervals5.emplace_back(QuicInterval<QuicPacketNumber>(
431 QuicPacketNumber(80), QuicPacketNumber(81)));
432
433 EXPECT_EQ(expected_intervals5, actual_intervals5);
434 }
435
TEST_F(QuicFramesTest,AddInterval)436 TEST_F(QuicFramesTest, AddInterval) {
437 QuicAckFrame ack_frame1;
438 ack_frame1.packets.AddRange(QuicPacketNumber(1), QuicPacketNumber(10));
439 ack_frame1.packets.AddRange(QuicPacketNumber(50), QuicPacketNumber(100));
440
441 EXPECT_EQ(2u, ack_frame1.packets.NumIntervals());
442 EXPECT_EQ(QuicPacketNumber(1u), ack_frame1.packets.Min());
443 EXPECT_EQ(QuicPacketNumber(99u), ack_frame1.packets.Max());
444
445 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals{
446 {QuicPacketNumber(1), QuicPacketNumber(10)},
447 {QuicPacketNumber(50), QuicPacketNumber(100)},
448 };
449
450 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals(
451 ack_frame1.packets.begin(), ack_frame1.packets.end());
452
453 EXPECT_EQ(expected_intervals, actual_intervals);
454
455 // Add a range in the middle.
456 ack_frame1.packets.AddRange(QuicPacketNumber(20), QuicPacketNumber(30));
457
458 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals2(
459 ack_frame1.packets.begin(), ack_frame1.packets.end());
460
461 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals2{
462 {QuicPacketNumber(1), QuicPacketNumber(10)},
463 {QuicPacketNumber(20), QuicPacketNumber(30)},
464 {QuicPacketNumber(50), QuicPacketNumber(100)},
465 };
466
467 EXPECT_EQ(expected_intervals2.size(), ack_frame1.packets.NumIntervals());
468 EXPECT_EQ(expected_intervals2, actual_intervals2);
469
470 // Add ranges at both ends.
471 QuicAckFrame ack_frame2;
472 ack_frame2.packets.AddRange(QuicPacketNumber(20), QuicPacketNumber(25));
473 ack_frame2.packets.AddRange(QuicPacketNumber(40), QuicPacketNumber(45));
474 ack_frame2.packets.AddRange(QuicPacketNumber(60), QuicPacketNumber(65));
475 ack_frame2.packets.AddRange(QuicPacketNumber(10), QuicPacketNumber(15));
476 ack_frame2.packets.AddRange(QuicPacketNumber(80), QuicPacketNumber(85));
477
478 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals8(
479 ack_frame2.packets.begin(), ack_frame2.packets.end());
480
481 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals8{
482 {QuicPacketNumber(10), QuicPacketNumber(15)},
483 {QuicPacketNumber(20), QuicPacketNumber(25)},
484 {QuicPacketNumber(40), QuicPacketNumber(45)},
485 {QuicPacketNumber(60), QuicPacketNumber(65)},
486 {QuicPacketNumber(80), QuicPacketNumber(85)},
487 };
488
489 EXPECT_EQ(expected_intervals8, actual_intervals8);
490 }
491
TEST_F(QuicFramesTest,AddAdjacentForward)492 TEST_F(QuicFramesTest, AddAdjacentForward) {
493 QuicAckFrame ack_frame1;
494 ack_frame1.packets.Add(QuicPacketNumber(49));
495 ack_frame1.packets.AddRange(QuicPacketNumber(50), QuicPacketNumber(60));
496 ack_frame1.packets.AddRange(QuicPacketNumber(60), QuicPacketNumber(70));
497 ack_frame1.packets.AddRange(QuicPacketNumber(70), QuicPacketNumber(100));
498
499 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals;
500 expected_intervals.emplace_back(QuicInterval<QuicPacketNumber>(
501 QuicPacketNumber(49), QuicPacketNumber(100)));
502
503 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals(
504 ack_frame1.packets.begin(), ack_frame1.packets.end());
505
506 EXPECT_EQ(expected_intervals, actual_intervals);
507 }
508
TEST_F(QuicFramesTest,AddAdjacentReverse)509 TEST_F(QuicFramesTest, AddAdjacentReverse) {
510 QuicAckFrame ack_frame1;
511 ack_frame1.packets.AddRange(QuicPacketNumber(70), QuicPacketNumber(100));
512 ack_frame1.packets.AddRange(QuicPacketNumber(60), QuicPacketNumber(70));
513 ack_frame1.packets.AddRange(QuicPacketNumber(50), QuicPacketNumber(60));
514 ack_frame1.packets.Add(QuicPacketNumber(49));
515
516 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals;
517 expected_intervals.emplace_back(QuicInterval<QuicPacketNumber>(
518 QuicPacketNumber(49), QuicPacketNumber(100)));
519
520 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals(
521 ack_frame1.packets.begin(), ack_frame1.packets.end());
522
523 EXPECT_EQ(expected_intervals, actual_intervals);
524 }
525
TEST_F(QuicFramesTest,RemoveSmallestInterval)526 TEST_F(QuicFramesTest, RemoveSmallestInterval) {
527 QuicAckFrame ack_frame1;
528 ack_frame1.largest_acked = QuicPacketNumber(100u);
529 ack_frame1.packets.AddRange(QuicPacketNumber(51), QuicPacketNumber(60));
530 ack_frame1.packets.AddRange(QuicPacketNumber(71), QuicPacketNumber(80));
531 ack_frame1.packets.AddRange(QuicPacketNumber(91), QuicPacketNumber(100));
532 ack_frame1.packets.RemoveSmallestInterval();
533 EXPECT_EQ(2u, ack_frame1.packets.NumIntervals());
534 EXPECT_EQ(QuicPacketNumber(71u), ack_frame1.packets.Min());
535 EXPECT_EQ(QuicPacketNumber(99u), ack_frame1.packets.Max());
536
537 ack_frame1.packets.RemoveSmallestInterval();
538 EXPECT_EQ(1u, ack_frame1.packets.NumIntervals());
539 EXPECT_EQ(QuicPacketNumber(91u), ack_frame1.packets.Min());
540 EXPECT_EQ(QuicPacketNumber(99u), ack_frame1.packets.Max());
541 }
542
TEST_F(QuicFramesTest,CopyQuicFrames)543 TEST_F(QuicFramesTest, CopyQuicFrames) {
544 QuicFrames frames;
545 QuicMessageFrame* message_frame =
546 new QuicMessageFrame(1, MemSliceFromString("message"));
547 // Construct a frame list.
548 for (uint8_t i = 0; i < NUM_FRAME_TYPES; ++i) {
549 switch (i) {
550 case PADDING_FRAME:
551 frames.push_back(QuicFrame(QuicPaddingFrame(-1)));
552 break;
553 case RST_STREAM_FRAME:
554 frames.push_back(QuicFrame(new QuicRstStreamFrame()));
555 break;
556 case CONNECTION_CLOSE_FRAME:
557 frames.push_back(QuicFrame(new QuicConnectionCloseFrame()));
558 break;
559 case GOAWAY_FRAME:
560 frames.push_back(QuicFrame(new QuicGoAwayFrame()));
561 break;
562 case WINDOW_UPDATE_FRAME:
563 frames.push_back(QuicFrame(QuicWindowUpdateFrame()));
564 break;
565 case BLOCKED_FRAME:
566 frames.push_back(QuicFrame(QuicBlockedFrame()));
567 break;
568 case STOP_WAITING_FRAME:
569 frames.push_back(QuicFrame(QuicStopWaitingFrame()));
570 break;
571 case PING_FRAME:
572 frames.push_back(QuicFrame(QuicPingFrame()));
573 break;
574 case CRYPTO_FRAME:
575 frames.push_back(QuicFrame(new QuicCryptoFrame()));
576 break;
577 case STREAM_FRAME:
578 frames.push_back(QuicFrame(QuicStreamFrame()));
579 break;
580 case ACK_FRAME:
581 frames.push_back(QuicFrame(new QuicAckFrame()));
582 break;
583 case MTU_DISCOVERY_FRAME:
584 frames.push_back(QuicFrame(QuicMtuDiscoveryFrame()));
585 break;
586 case NEW_CONNECTION_ID_FRAME:
587 frames.push_back(QuicFrame(new QuicNewConnectionIdFrame()));
588 break;
589 case MAX_STREAMS_FRAME:
590 frames.push_back(QuicFrame(QuicMaxStreamsFrame()));
591 break;
592 case STREAMS_BLOCKED_FRAME:
593 frames.push_back(QuicFrame(QuicStreamsBlockedFrame()));
594 break;
595 case PATH_RESPONSE_FRAME:
596 frames.push_back(QuicFrame(QuicPathResponseFrame()));
597 break;
598 case PATH_CHALLENGE_FRAME:
599 frames.push_back(QuicFrame(QuicPathChallengeFrame()));
600 break;
601 case STOP_SENDING_FRAME:
602 frames.push_back(QuicFrame(QuicStopSendingFrame()));
603 break;
604 case MESSAGE_FRAME:
605 frames.push_back(QuicFrame(message_frame));
606 break;
607 case NEW_TOKEN_FRAME:
608 frames.push_back(QuicFrame(new QuicNewTokenFrame()));
609 break;
610 case RETIRE_CONNECTION_ID_FRAME:
611 frames.push_back(QuicFrame(new QuicRetireConnectionIdFrame()));
612 break;
613 case HANDSHAKE_DONE_FRAME:
614 frames.push_back(QuicFrame(QuicHandshakeDoneFrame()));
615 break;
616 case ACK_FREQUENCY_FRAME:
617 frames.push_back(QuicFrame(new QuicAckFrequencyFrame()));
618 break;
619 default:
620 ASSERT_TRUE(false)
621 << "Please fix CopyQuicFrames if a new frame type is added.";
622 break;
623 }
624 }
625
626 QuicFrames copy =
627 CopyQuicFrames(quiche::SimpleBufferAllocator::Get(), frames);
628 ASSERT_EQ(NUM_FRAME_TYPES, copy.size());
629 for (uint8_t i = 0; i < NUM_FRAME_TYPES; ++i) {
630 EXPECT_EQ(i, copy[i].type);
631 if (i == MESSAGE_FRAME) {
632 // Verify message frame is correctly copied.
633 EXPECT_EQ(1u, copy[i].message_frame->message_id);
634 EXPECT_EQ(nullptr, copy[i].message_frame->data);
635 EXPECT_EQ(7u, copy[i].message_frame->message_length);
636 ASSERT_EQ(1u, copy[i].message_frame->message_data.size());
637 EXPECT_EQ(0, memcmp(copy[i].message_frame->message_data[0].data(),
638 frames[i].message_frame->message_data[0].data(), 7));
639 } else if (i == PATH_CHALLENGE_FRAME) {
640 EXPECT_EQ(copy[i].path_challenge_frame.control_frame_id,
641 frames[i].path_challenge_frame.control_frame_id);
642 EXPECT_EQ(memcmp(©[i].path_challenge_frame.data_buffer,
643 &frames[i].path_challenge_frame.data_buffer,
644 copy[i].path_challenge_frame.data_buffer.size()),
645 0);
646 } else if (i == PATH_RESPONSE_FRAME) {
647 EXPECT_EQ(copy[i].path_response_frame.control_frame_id,
648 frames[i].path_response_frame.control_frame_id);
649 EXPECT_EQ(memcmp(©[i].path_response_frame.data_buffer,
650 &frames[i].path_response_frame.data_buffer,
651 copy[i].path_response_frame.data_buffer.size()),
652 0);
653 }
654 }
655 DeleteFrames(&frames);
656 DeleteFrames(©);
657 }
658
659 class PacketNumberQueueTest : public QuicTest {};
660
661 // Tests that a queue contains the expected data after calls to Add().
TEST_F(PacketNumberQueueTest,AddRange)662 TEST_F(PacketNumberQueueTest, AddRange) {
663 PacketNumberQueue queue;
664 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(51));
665 queue.Add(QuicPacketNumber(53));
666
667 EXPECT_FALSE(queue.Contains(QuicPacketNumber()));
668 for (int i = 1; i < 51; ++i) {
669 EXPECT_TRUE(queue.Contains(QuicPacketNumber(i)));
670 }
671 EXPECT_FALSE(queue.Contains(QuicPacketNumber(51)));
672 EXPECT_FALSE(queue.Contains(QuicPacketNumber(52)));
673 EXPECT_TRUE(queue.Contains(QuicPacketNumber(53)));
674 EXPECT_FALSE(queue.Contains(QuicPacketNumber(54)));
675 EXPECT_EQ(51u, queue.NumPacketsSlow());
676 EXPECT_EQ(QuicPacketNumber(1u), queue.Min());
677 EXPECT_EQ(QuicPacketNumber(53u), queue.Max());
678
679 queue.Add(QuicPacketNumber(70));
680 EXPECT_EQ(QuicPacketNumber(70u), queue.Max());
681 }
682
683 // Tests Contains function
TEST_F(PacketNumberQueueTest,Contains)684 TEST_F(PacketNumberQueueTest, Contains) {
685 PacketNumberQueue queue;
686 EXPECT_FALSE(queue.Contains(QuicPacketNumber()));
687 queue.AddRange(QuicPacketNumber(5), QuicPacketNumber(10));
688 queue.Add(QuicPacketNumber(20));
689
690 for (int i = 1; i < 5; ++i) {
691 EXPECT_FALSE(queue.Contains(QuicPacketNumber(i)));
692 }
693
694 for (int i = 5; i < 10; ++i) {
695 EXPECT_TRUE(queue.Contains(QuicPacketNumber(i)));
696 }
697 for (int i = 10; i < 20; ++i) {
698 EXPECT_FALSE(queue.Contains(QuicPacketNumber(i)));
699 }
700 EXPECT_TRUE(queue.Contains(QuicPacketNumber(20)));
701 EXPECT_FALSE(queue.Contains(QuicPacketNumber(21)));
702
703 PacketNumberQueue queue2;
704 EXPECT_FALSE(queue2.Contains(QuicPacketNumber(1)));
705 for (int i = 1; i < 51; ++i) {
706 queue2.Add(QuicPacketNumber(2 * i));
707 }
708 EXPECT_FALSE(queue2.Contains(QuicPacketNumber()));
709 for (int i = 1; i < 51; ++i) {
710 if (i % 2 == 0) {
711 EXPECT_TRUE(queue2.Contains(QuicPacketNumber(i)));
712 } else {
713 EXPECT_FALSE(queue2.Contains(QuicPacketNumber(i)));
714 }
715 }
716 EXPECT_FALSE(queue2.Contains(QuicPacketNumber(101)));
717 }
718
719 // Tests that a queue contains the expected data after calls to RemoveUpTo().
TEST_F(PacketNumberQueueTest,Removal)720 TEST_F(PacketNumberQueueTest, Removal) {
721 PacketNumberQueue queue;
722 EXPECT_FALSE(queue.Contains(QuicPacketNumber(51)));
723 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(100));
724
725 EXPECT_TRUE(queue.RemoveUpTo(QuicPacketNumber(51)));
726 EXPECT_FALSE(queue.RemoveUpTo(QuicPacketNumber(51)));
727
728 EXPECT_FALSE(queue.Contains(QuicPacketNumber()));
729 for (int i = 1; i < 51; ++i) {
730 EXPECT_FALSE(queue.Contains(QuicPacketNumber(i)));
731 }
732 for (int i = 51; i < 100; ++i) {
733 EXPECT_TRUE(queue.Contains(QuicPacketNumber(i)));
734 }
735 EXPECT_EQ(49u, queue.NumPacketsSlow());
736 EXPECT_EQ(QuicPacketNumber(51u), queue.Min());
737 EXPECT_EQ(QuicPacketNumber(99u), queue.Max());
738
739 PacketNumberQueue queue2;
740 queue2.AddRange(QuicPacketNumber(1), QuicPacketNumber(5));
741 EXPECT_TRUE(queue2.RemoveUpTo(QuicPacketNumber(3)));
742 EXPECT_TRUE(queue2.RemoveUpTo(QuicPacketNumber(50)));
743 EXPECT_TRUE(queue2.Empty());
744 }
745
746 // Tests that a queue is empty when all of its elements are removed.
TEST_F(PacketNumberQueueTest,Empty)747 TEST_F(PacketNumberQueueTest, Empty) {
748 PacketNumberQueue queue;
749 EXPECT_TRUE(queue.Empty());
750 EXPECT_EQ(0u, queue.NumPacketsSlow());
751
752 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(100));
753 EXPECT_TRUE(queue.RemoveUpTo(QuicPacketNumber(100)));
754 EXPECT_TRUE(queue.Empty());
755 EXPECT_EQ(0u, queue.NumPacketsSlow());
756 }
757
758 // Tests that logging the state of a PacketNumberQueue does not crash.
TEST_F(PacketNumberQueueTest,LogDoesNotCrash)759 TEST_F(PacketNumberQueueTest, LogDoesNotCrash) {
760 std::ostringstream oss;
761 PacketNumberQueue queue;
762 oss << queue;
763
764 queue.Add(QuicPacketNumber(1));
765 queue.AddRange(QuicPacketNumber(50), QuicPacketNumber(100));
766 oss << queue;
767 }
768
769 // Tests that the iterators returned from a packet queue iterate over the queue.
TEST_F(PacketNumberQueueTest,Iterators)770 TEST_F(PacketNumberQueueTest, Iterators) {
771 PacketNumberQueue queue;
772 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(100));
773
774 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals(
775 queue.begin(), queue.end());
776
777 PacketNumberQueue queue2;
778 for (int i = 1; i < 100; i++) {
779 queue2.AddRange(QuicPacketNumber(i), QuicPacketNumber(i + 1));
780 }
781
782 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals2(
783 queue2.begin(), queue2.end());
784
785 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals;
786 expected_intervals.emplace_back(QuicInterval<QuicPacketNumber>(
787 QuicPacketNumber(1), QuicPacketNumber(100)));
788 EXPECT_EQ(expected_intervals, actual_intervals);
789 EXPECT_EQ(expected_intervals, actual_intervals2);
790 EXPECT_EQ(actual_intervals, actual_intervals2);
791 }
792
TEST_F(PacketNumberQueueTest,ReversedIterators)793 TEST_F(PacketNumberQueueTest, ReversedIterators) {
794 PacketNumberQueue queue;
795 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(100));
796 PacketNumberQueue queue2;
797 for (int i = 1; i < 100; i++) {
798 queue2.AddRange(QuicPacketNumber(i), QuicPacketNumber(i + 1));
799 }
800 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals(
801 queue.rbegin(), queue.rend());
802 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals2(
803 queue2.rbegin(), queue2.rend());
804
805 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals;
806 expected_intervals.emplace_back(QuicInterval<QuicPacketNumber>(
807 QuicPacketNumber(1), QuicPacketNumber(100)));
808
809 EXPECT_EQ(expected_intervals, actual_intervals);
810 EXPECT_EQ(expected_intervals, actual_intervals2);
811 EXPECT_EQ(actual_intervals, actual_intervals2);
812
813 PacketNumberQueue queue3;
814 for (int i = 1; i < 20; i++) {
815 queue3.Add(QuicPacketNumber(2 * i));
816 }
817
818 auto begin = queue3.begin();
819 auto end = queue3.end();
820 --end;
821 auto rbegin = queue3.rbegin();
822 auto rend = queue3.rend();
823 --rend;
824
825 EXPECT_EQ(*begin, *rend);
826 EXPECT_EQ(*rbegin, *end);
827 }
828
TEST_F(PacketNumberQueueTest,IntervalLengthAndRemoveInterval)829 TEST_F(PacketNumberQueueTest, IntervalLengthAndRemoveInterval) {
830 PacketNumberQueue queue;
831 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(10));
832 queue.AddRange(QuicPacketNumber(20), QuicPacketNumber(30));
833 queue.AddRange(QuicPacketNumber(40), QuicPacketNumber(50));
834 EXPECT_EQ(3u, queue.NumIntervals());
835 EXPECT_EQ(10u, queue.LastIntervalLength());
836
837 EXPECT_TRUE(queue.RemoveUpTo(QuicPacketNumber(25)));
838 EXPECT_EQ(2u, queue.NumIntervals());
839 EXPECT_EQ(10u, queue.LastIntervalLength());
840 EXPECT_EQ(QuicPacketNumber(25u), queue.Min());
841 EXPECT_EQ(QuicPacketNumber(49u), queue.Max());
842 }
843
844 } // namespace
845 } // namespace test
846 } // namespace quic
847