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 case RESET_STREAM_AT_FRAME:
620 frames.push_back(QuicFrame(new QuicResetStreamAtFrame()));
621 break;
622 default:
623 ASSERT_TRUE(false)
624 << "Please fix CopyQuicFrames if a new frame type is added.";
625 break;
626 }
627 }
628
629 QuicFrames copy =
630 CopyQuicFrames(quiche::SimpleBufferAllocator::Get(), frames);
631 ASSERT_EQ(NUM_FRAME_TYPES, copy.size());
632 for (uint8_t i = 0; i < NUM_FRAME_TYPES; ++i) {
633 EXPECT_EQ(i, copy[i].type);
634 if (i == MESSAGE_FRAME) {
635 // Verify message frame is correctly copied.
636 EXPECT_EQ(1u, copy[i].message_frame->message_id);
637 EXPECT_EQ(nullptr, copy[i].message_frame->data);
638 EXPECT_EQ(7u, copy[i].message_frame->message_length);
639 ASSERT_EQ(1u, copy[i].message_frame->message_data.size());
640 EXPECT_EQ(0, memcmp(copy[i].message_frame->message_data[0].data(),
641 frames[i].message_frame->message_data[0].data(), 7));
642 } else if (i == PATH_CHALLENGE_FRAME) {
643 EXPECT_EQ(copy[i].path_challenge_frame.control_frame_id,
644 frames[i].path_challenge_frame.control_frame_id);
645 EXPECT_EQ(memcmp(©[i].path_challenge_frame.data_buffer,
646 &frames[i].path_challenge_frame.data_buffer,
647 copy[i].path_challenge_frame.data_buffer.size()),
648 0);
649 } else if (i == PATH_RESPONSE_FRAME) {
650 EXPECT_EQ(copy[i].path_response_frame.control_frame_id,
651 frames[i].path_response_frame.control_frame_id);
652 EXPECT_EQ(memcmp(©[i].path_response_frame.data_buffer,
653 &frames[i].path_response_frame.data_buffer,
654 copy[i].path_response_frame.data_buffer.size()),
655 0);
656 }
657 }
658 DeleteFrames(&frames);
659 DeleteFrames(©);
660 }
661
662 class PacketNumberQueueTest : public QuicTest {};
663
664 // Tests that a queue contains the expected data after calls to Add().
TEST_F(PacketNumberQueueTest,AddRange)665 TEST_F(PacketNumberQueueTest, AddRange) {
666 PacketNumberQueue queue;
667 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(51));
668 queue.Add(QuicPacketNumber(53));
669
670 EXPECT_FALSE(queue.Contains(QuicPacketNumber()));
671 for (int i = 1; i < 51; ++i) {
672 EXPECT_TRUE(queue.Contains(QuicPacketNumber(i)));
673 }
674 EXPECT_FALSE(queue.Contains(QuicPacketNumber(51)));
675 EXPECT_FALSE(queue.Contains(QuicPacketNumber(52)));
676 EXPECT_TRUE(queue.Contains(QuicPacketNumber(53)));
677 EXPECT_FALSE(queue.Contains(QuicPacketNumber(54)));
678 EXPECT_EQ(51u, queue.NumPacketsSlow());
679 EXPECT_EQ(QuicPacketNumber(1u), queue.Min());
680 EXPECT_EQ(QuicPacketNumber(53u), queue.Max());
681
682 queue.Add(QuicPacketNumber(70));
683 EXPECT_EQ(QuicPacketNumber(70u), queue.Max());
684 }
685
686 // Tests Contains function
TEST_F(PacketNumberQueueTest,Contains)687 TEST_F(PacketNumberQueueTest, Contains) {
688 PacketNumberQueue queue;
689 EXPECT_FALSE(queue.Contains(QuicPacketNumber()));
690 queue.AddRange(QuicPacketNumber(5), QuicPacketNumber(10));
691 queue.Add(QuicPacketNumber(20));
692
693 for (int i = 1; i < 5; ++i) {
694 EXPECT_FALSE(queue.Contains(QuicPacketNumber(i)));
695 }
696
697 for (int i = 5; i < 10; ++i) {
698 EXPECT_TRUE(queue.Contains(QuicPacketNumber(i)));
699 }
700 for (int i = 10; i < 20; ++i) {
701 EXPECT_FALSE(queue.Contains(QuicPacketNumber(i)));
702 }
703 EXPECT_TRUE(queue.Contains(QuicPacketNumber(20)));
704 EXPECT_FALSE(queue.Contains(QuicPacketNumber(21)));
705
706 PacketNumberQueue queue2;
707 EXPECT_FALSE(queue2.Contains(QuicPacketNumber(1)));
708 for (int i = 1; i < 51; ++i) {
709 queue2.Add(QuicPacketNumber(2 * i));
710 }
711 EXPECT_FALSE(queue2.Contains(QuicPacketNumber()));
712 for (int i = 1; i < 51; ++i) {
713 if (i % 2 == 0) {
714 EXPECT_TRUE(queue2.Contains(QuicPacketNumber(i)));
715 } else {
716 EXPECT_FALSE(queue2.Contains(QuicPacketNumber(i)));
717 }
718 }
719 EXPECT_FALSE(queue2.Contains(QuicPacketNumber(101)));
720 }
721
722 // Tests that a queue contains the expected data after calls to RemoveUpTo().
TEST_F(PacketNumberQueueTest,Removal)723 TEST_F(PacketNumberQueueTest, Removal) {
724 PacketNumberQueue queue;
725 EXPECT_FALSE(queue.Contains(QuicPacketNumber(51)));
726 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(100));
727
728 EXPECT_TRUE(queue.RemoveUpTo(QuicPacketNumber(51)));
729 EXPECT_FALSE(queue.RemoveUpTo(QuicPacketNumber(51)));
730
731 EXPECT_FALSE(queue.Contains(QuicPacketNumber()));
732 for (int i = 1; i < 51; ++i) {
733 EXPECT_FALSE(queue.Contains(QuicPacketNumber(i)));
734 }
735 for (int i = 51; i < 100; ++i) {
736 EXPECT_TRUE(queue.Contains(QuicPacketNumber(i)));
737 }
738 EXPECT_EQ(49u, queue.NumPacketsSlow());
739 EXPECT_EQ(QuicPacketNumber(51u), queue.Min());
740 EXPECT_EQ(QuicPacketNumber(99u), queue.Max());
741
742 PacketNumberQueue queue2;
743 queue2.AddRange(QuicPacketNumber(1), QuicPacketNumber(5));
744 EXPECT_TRUE(queue2.RemoveUpTo(QuicPacketNumber(3)));
745 EXPECT_TRUE(queue2.RemoveUpTo(QuicPacketNumber(50)));
746 EXPECT_TRUE(queue2.Empty());
747 }
748
749 // Tests that a queue is empty when all of its elements are removed.
TEST_F(PacketNumberQueueTest,Empty)750 TEST_F(PacketNumberQueueTest, Empty) {
751 PacketNumberQueue queue;
752 EXPECT_TRUE(queue.Empty());
753 EXPECT_EQ(0u, queue.NumPacketsSlow());
754
755 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(100));
756 EXPECT_TRUE(queue.RemoveUpTo(QuicPacketNumber(100)));
757 EXPECT_TRUE(queue.Empty());
758 EXPECT_EQ(0u, queue.NumPacketsSlow());
759 }
760
761 // Tests that logging the state of a PacketNumberQueue does not crash.
TEST_F(PacketNumberQueueTest,LogDoesNotCrash)762 TEST_F(PacketNumberQueueTest, LogDoesNotCrash) {
763 std::ostringstream oss;
764 PacketNumberQueue queue;
765 oss << queue;
766
767 queue.Add(QuicPacketNumber(1));
768 queue.AddRange(QuicPacketNumber(50), QuicPacketNumber(100));
769 oss << queue;
770 }
771
772 // Tests that the iterators returned from a packet queue iterate over the queue.
TEST_F(PacketNumberQueueTest,Iterators)773 TEST_F(PacketNumberQueueTest, Iterators) {
774 PacketNumberQueue queue;
775 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(100));
776
777 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals(
778 queue.begin(), queue.end());
779
780 PacketNumberQueue queue2;
781 for (int i = 1; i < 100; i++) {
782 queue2.AddRange(QuicPacketNumber(i), QuicPacketNumber(i + 1));
783 }
784
785 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals2(
786 queue2.begin(), queue2.end());
787
788 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals;
789 expected_intervals.emplace_back(QuicInterval<QuicPacketNumber>(
790 QuicPacketNumber(1), QuicPacketNumber(100)));
791 EXPECT_EQ(expected_intervals, actual_intervals);
792 EXPECT_EQ(expected_intervals, actual_intervals2);
793 EXPECT_EQ(actual_intervals, actual_intervals2);
794 }
795
TEST_F(PacketNumberQueueTest,ReversedIterators)796 TEST_F(PacketNumberQueueTest, ReversedIterators) {
797 PacketNumberQueue queue;
798 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(100));
799 PacketNumberQueue queue2;
800 for (int i = 1; i < 100; i++) {
801 queue2.AddRange(QuicPacketNumber(i), QuicPacketNumber(i + 1));
802 }
803 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals(
804 queue.rbegin(), queue.rend());
805 const std::vector<QuicInterval<QuicPacketNumber>> actual_intervals2(
806 queue2.rbegin(), queue2.rend());
807
808 std::vector<QuicInterval<QuicPacketNumber>> expected_intervals;
809 expected_intervals.emplace_back(QuicInterval<QuicPacketNumber>(
810 QuicPacketNumber(1), QuicPacketNumber(100)));
811
812 EXPECT_EQ(expected_intervals, actual_intervals);
813 EXPECT_EQ(expected_intervals, actual_intervals2);
814 EXPECT_EQ(actual_intervals, actual_intervals2);
815
816 PacketNumberQueue queue3;
817 for (int i = 1; i < 20; i++) {
818 queue3.Add(QuicPacketNumber(2 * i));
819 }
820
821 auto begin = queue3.begin();
822 auto end = queue3.end();
823 --end;
824 auto rbegin = queue3.rbegin();
825 auto rend = queue3.rend();
826 --rend;
827
828 EXPECT_EQ(*begin, *rend);
829 EXPECT_EQ(*rbegin, *end);
830 }
831
TEST_F(PacketNumberQueueTest,IntervalLengthAndRemoveInterval)832 TEST_F(PacketNumberQueueTest, IntervalLengthAndRemoveInterval) {
833 PacketNumberQueue queue;
834 queue.AddRange(QuicPacketNumber(1), QuicPacketNumber(10));
835 queue.AddRange(QuicPacketNumber(20), QuicPacketNumber(30));
836 queue.AddRange(QuicPacketNumber(40), QuicPacketNumber(50));
837 EXPECT_EQ(3u, queue.NumIntervals());
838 EXPECT_EQ(10u, queue.LastIntervalLength());
839
840 EXPECT_TRUE(queue.RemoveUpTo(QuicPacketNumber(25)));
841 EXPECT_EQ(2u, queue.NumIntervals());
842 EXPECT_EQ(10u, queue.LastIntervalLength());
843 EXPECT_EQ(QuicPacketNumber(25u), queue.Min());
844 EXPECT_EQ(QuicPacketNumber(49u), queue.Max());
845 }
846
847 } // namespace
848 } // namespace test
849 } // namespace quic
850