1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "net/quic/quic_packet_creator.h"
6
7 #include "base/stl_util.h"
8 #include "net/quic/crypto/null_encrypter.h"
9 #include "net/quic/crypto/quic_decrypter.h"
10 #include "net/quic/crypto/quic_encrypter.h"
11 #include "net/quic/quic_utils.h"
12 #include "net/quic/test_tools/mock_random.h"
13 #include "net/quic/test_tools/quic_packet_creator_peer.h"
14 #include "net/quic/test_tools/quic_test_utils.h"
15 #include "testing/gmock/include/gmock/gmock.h"
16
17 using base::StringPiece;
18 using std::string;
19 using std::vector;
20 using testing::DoAll;
21 using testing::InSequence;
22 using testing::Return;
23 using testing::SaveArg;
24 using testing::_;
25
26 namespace net {
27 namespace test {
28 namespace {
29
30 class QuicPacketCreatorTest : public ::testing::TestWithParam<bool> {
31 protected:
QuicPacketCreatorTest()32 QuicPacketCreatorTest()
33 : server_framer_(QuicSupportedVersions(), QuicTime::Zero(), true),
34 client_framer_(QuicSupportedVersions(), QuicTime::Zero(), false),
35 sequence_number_(0),
36 guid_(2),
37 data_("foo"),
38 creator_(guid_, &client_framer_, &mock_random_, false) {
39 client_framer_.set_visitor(&framer_visitor_);
40 server_framer_.set_visitor(&framer_visitor_);
41 }
~QuicPacketCreatorTest()42 ~QuicPacketCreatorTest() {
43 }
44
ProcessPacket(QuicPacket * packet)45 void ProcessPacket(QuicPacket* packet) {
46 scoped_ptr<QuicEncryptedPacket> encrypted(
47 server_framer_.EncryptPacket(ENCRYPTION_NONE, sequence_number_,
48 *packet));
49 server_framer_.ProcessPacket(*encrypted);
50 }
51
CheckStreamFrame(const QuicFrame & frame,QuicStreamId stream_id,const string & data,QuicStreamOffset offset,bool fin)52 void CheckStreamFrame(const QuicFrame& frame,
53 QuicStreamId stream_id,
54 const string& data,
55 QuicStreamOffset offset,
56 bool fin) {
57 EXPECT_EQ(STREAM_FRAME, frame.type);
58 ASSERT_TRUE(frame.stream_frame);
59 EXPECT_EQ(stream_id, frame.stream_frame->stream_id);
60 scoped_ptr<string> frame_data(frame.stream_frame->GetDataAsString());
61 EXPECT_EQ(data, *frame_data);
62 EXPECT_EQ(offset, frame.stream_frame->offset);
63 EXPECT_EQ(fin, frame.stream_frame->fin);
64 }
65
66 // Returns the number of bytes consumed by the header of packet, including
67 // the version, that is not in an FEC group.
GetPacketHeaderOverhead()68 size_t GetPacketHeaderOverhead() {
69 return GetPacketHeaderSize(creator_.options()->send_guid_length,
70 kIncludeVersion,
71 creator_.options()->send_sequence_number_length,
72 NOT_IN_FEC_GROUP);
73 }
74
75 // Returns the number of bytes of overhead that will be added to a packet
76 // of maximum length.
GetEncryptionOverhead()77 size_t GetEncryptionOverhead() {
78 return creator_.options()->max_packet_length -
79 client_framer_.GetMaxPlaintextSize(
80 creator_.options()->max_packet_length);
81 }
82
83 // Returns the number of bytes consumed by the non-data fields of a stream
84 // frame, assuming it is the last frame in the packet
GetStreamFrameOverhead()85 size_t GetStreamFrameOverhead() {
86 return QuicFramer::GetMinStreamFrameSize(
87 client_framer_.version(), kStreamId, kOffset, true);
88 }
89
90 static const QuicStreamId kStreamId = 1u;
91 static const QuicStreamOffset kOffset = 1u;
92
93 QuicFrames frames_;
94 QuicFramer server_framer_;
95 QuicFramer client_framer_;
96 testing::StrictMock<MockFramerVisitor> framer_visitor_;
97 QuicPacketSequenceNumber sequence_number_;
98 QuicGuid guid_;
99 string data_;
100 MockRandom mock_random_;
101 QuicPacketCreator creator_;
102 };
103
TEST_F(QuicPacketCreatorTest,SerializeFrames)104 TEST_F(QuicPacketCreatorTest, SerializeFrames) {
105 frames_.push_back(QuicFrame(new QuicAckFrame(0u, QuicTime::Zero(), 0u)));
106 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
107 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, true, 0u, IOVector())));
108 SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
109 delete frames_[0].ack_frame;
110 delete frames_[1].stream_frame;
111 delete frames_[2].stream_frame;
112
113 {
114 InSequence s;
115 EXPECT_CALL(framer_visitor_, OnPacket());
116 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
117 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
118 EXPECT_CALL(framer_visitor_, OnAckFrame(_));
119 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
120 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
121 EXPECT_CALL(framer_visitor_, OnPacketComplete());
122 }
123 ProcessPacket(serialized.packet);
124 delete serialized.packet;
125 }
126
TEST_F(QuicPacketCreatorTest,SerializeWithFEC)127 TEST_F(QuicPacketCreatorTest, SerializeWithFEC) {
128 creator_.options()->max_packets_per_fec_group = 6;
129 ASSERT_FALSE(creator_.ShouldSendFec(false));
130
131 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
132 SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
133 delete frames_[0].stream_frame;
134
135 {
136 InSequence s;
137 EXPECT_CALL(framer_visitor_, OnPacket());
138 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
139 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
140 EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
141 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
142 EXPECT_CALL(framer_visitor_, OnPacketComplete());
143 }
144 ProcessPacket(serialized.packet);
145 delete serialized.packet;
146
147 ASSERT_FALSE(creator_.ShouldSendFec(false));
148 ASSERT_TRUE(creator_.ShouldSendFec(true));
149
150 serialized = creator_.SerializeFec();
151 ASSERT_EQ(2u, serialized.sequence_number);
152
153 {
154 InSequence s;
155 EXPECT_CALL(framer_visitor_, OnPacket());
156 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
157 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
158 EXPECT_CALL(framer_visitor_, OnFecData(_));
159 EXPECT_CALL(framer_visitor_, OnPacketComplete());
160 }
161 ProcessPacket(serialized.packet);
162 delete serialized.packet;
163 }
164
TEST_F(QuicPacketCreatorTest,SerializeChangingSequenceNumberLength)165 TEST_F(QuicPacketCreatorTest, SerializeChangingSequenceNumberLength) {
166 frames_.push_back(QuicFrame(new QuicAckFrame(0u, QuicTime::Zero(), 0u)));
167 creator_.AddSavedFrame(frames_[0]);
168 creator_.options()->send_sequence_number_length =
169 PACKET_4BYTE_SEQUENCE_NUMBER;
170 SerializedPacket serialized = creator_.SerializePacket();
171 // The sequence number length will not change mid-packet.
172 EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
173
174 {
175 InSequence s;
176 EXPECT_CALL(framer_visitor_, OnPacket());
177 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
178 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
179 EXPECT_CALL(framer_visitor_, OnAckFrame(_));
180 EXPECT_CALL(framer_visitor_, OnPacketComplete());
181 }
182 ProcessPacket(serialized.packet);
183 delete serialized.packet;
184
185 creator_.AddSavedFrame(frames_[0]);
186 serialized = creator_.SerializePacket();
187 // Now the actual sequence number length should have changed.
188 EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
189 delete frames_[0].ack_frame;
190
191 {
192 InSequence s;
193 EXPECT_CALL(framer_visitor_, OnPacket());
194 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
195 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
196 EXPECT_CALL(framer_visitor_, OnAckFrame(_));
197 EXPECT_CALL(framer_visitor_, OnPacketComplete());
198 }
199 ProcessPacket(serialized.packet);
200 delete serialized.packet;
201 }
202
TEST_F(QuicPacketCreatorTest,SerializeWithFECChangingSequenceNumberLength)203 TEST_F(QuicPacketCreatorTest, SerializeWithFECChangingSequenceNumberLength) {
204 creator_.options()->max_packets_per_fec_group = 6;
205 ASSERT_FALSE(creator_.ShouldSendFec(false));
206
207 frames_.push_back(QuicFrame(new QuicAckFrame(0u, QuicTime::Zero(), 0u)));
208 creator_.AddSavedFrame(frames_[0]);
209 // Change the sequence number length mid-FEC group and it should not change.
210 creator_.options()->send_sequence_number_length =
211 PACKET_4BYTE_SEQUENCE_NUMBER;
212 SerializedPacket serialized = creator_.SerializePacket();
213 EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
214
215 {
216 InSequence s;
217 EXPECT_CALL(framer_visitor_, OnPacket());
218 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
219 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
220 EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
221 EXPECT_CALL(framer_visitor_, OnAckFrame(_));
222 EXPECT_CALL(framer_visitor_, OnPacketComplete());
223 }
224 ProcessPacket(serialized.packet);
225 delete serialized.packet;
226
227 ASSERT_FALSE(creator_.ShouldSendFec(false));
228 ASSERT_TRUE(creator_.ShouldSendFec(true));
229
230 serialized = creator_.SerializeFec();
231 EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
232 ASSERT_EQ(2u, serialized.sequence_number);
233
234 {
235 InSequence s;
236 EXPECT_CALL(framer_visitor_, OnPacket());
237 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
238 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
239 EXPECT_CALL(framer_visitor_, OnFecData(_));
240 EXPECT_CALL(framer_visitor_, OnPacketComplete());
241 }
242 ProcessPacket(serialized.packet);
243 delete serialized.packet;
244
245 // Ensure the next FEC group starts using the new sequence number length.
246 serialized = creator_.SerializeAllFrames(frames_);
247 EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
248 delete frames_[0].ack_frame;
249 delete serialized.packet;
250 }
251
TEST_F(QuicPacketCreatorTest,ReserializeFramesWithSequenceNumberLength)252 TEST_F(QuicPacketCreatorTest, ReserializeFramesWithSequenceNumberLength) {
253 // If the original packet sequence number length, the current sequence number
254 // length, and the configured send sequence number length are different, the
255 // retransmit must sent with the original length and the others do not change.
256 creator_.options()->send_sequence_number_length =
257 PACKET_4BYTE_SEQUENCE_NUMBER;
258 QuicPacketCreatorPeer::SetSequenceNumberLength(&creator_,
259 PACKET_2BYTE_SEQUENCE_NUMBER);
260 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
261 SerializedPacket serialized =
262 creator_.ReserializeAllFrames(frames_, PACKET_1BYTE_SEQUENCE_NUMBER);
263 EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
264 creator_.options()->send_sequence_number_length);
265 EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
266 QuicPacketCreatorPeer::GetSequenceNumberLength(&creator_));
267 EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER, serialized.sequence_number_length);
268 delete frames_[0].stream_frame;
269
270 {
271 InSequence s;
272 EXPECT_CALL(framer_visitor_, OnPacket());
273 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
274 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
275 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
276 EXPECT_CALL(framer_visitor_, OnPacketComplete());
277 }
278 ProcessPacket(serialized.packet);
279 delete serialized.packet;
280 }
281
TEST_F(QuicPacketCreatorTest,SerializeConnectionClose)282 TEST_F(QuicPacketCreatorTest, SerializeConnectionClose) {
283 QuicConnectionCloseFrame frame;
284 frame.error_code = QUIC_NO_ERROR;
285 frame.error_details = "error";
286
287 SerializedPacket serialized = creator_.SerializeConnectionClose(&frame);
288 ASSERT_EQ(1u, serialized.sequence_number);
289 ASSERT_EQ(1u, creator_.sequence_number());
290
291 InSequence s;
292 EXPECT_CALL(framer_visitor_, OnPacket());
293 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
294 EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
295 EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_));
296 EXPECT_CALL(framer_visitor_, OnPacketComplete());
297
298 ProcessPacket(serialized.packet);
299 delete serialized.packet;
300 }
301
TEST_F(QuicPacketCreatorTest,CreateStreamFrame)302 TEST_F(QuicPacketCreatorTest, CreateStreamFrame) {
303 QuicFrame frame;
304 size_t consumed = creator_.CreateStreamFrame(1u, MakeIOVector("test"), 0u,
305 false, &frame);
306 EXPECT_EQ(4u, consumed);
307 CheckStreamFrame(frame, 1u, "test", 0u, false);
308 delete frame.stream_frame;
309 }
310
TEST_F(QuicPacketCreatorTest,CreateStreamFrameFin)311 TEST_F(QuicPacketCreatorTest, CreateStreamFrameFin) {
312 QuicFrame frame;
313 size_t consumed = creator_.CreateStreamFrame(1u, MakeIOVector("test"), 10u,
314 true, &frame);
315 EXPECT_EQ(4u, consumed);
316 CheckStreamFrame(frame, 1u, "test", 10u, true);
317 delete frame.stream_frame;
318 }
319
TEST_F(QuicPacketCreatorTest,CreateStreamFrameFinOnly)320 TEST_F(QuicPacketCreatorTest, CreateStreamFrameFinOnly) {
321 QuicFrame frame;
322 size_t consumed = creator_.CreateStreamFrame(1u, IOVector(), 0u, true,
323 &frame);
324 EXPECT_EQ(0u, consumed);
325 CheckStreamFrame(frame, 1u, string(), 0u, true);
326 delete frame.stream_frame;
327 }
328
TEST_F(QuicPacketCreatorTest,CreateAllFreeBytesForStreamFrames)329 TEST_F(QuicPacketCreatorTest, CreateAllFreeBytesForStreamFrames) {
330 const size_t overhead = GetPacketHeaderOverhead() + GetEncryptionOverhead();
331 for (size_t i = overhead; i < overhead + 100; ++i) {
332 creator_.options()->max_packet_length = i;
333 const bool should_have_room = i > overhead + GetStreamFrameOverhead();
334 ASSERT_EQ(should_have_room,
335 creator_.HasRoomForStreamFrame(kStreamId, kOffset));
336 if (should_have_room) {
337 QuicFrame frame;
338 size_t bytes_consumed = creator_.CreateStreamFrame(
339 kStreamId, MakeIOVector("testdata"), kOffset, false, &frame);
340 EXPECT_LT(0u, bytes_consumed);
341 ASSERT_TRUE(creator_.AddSavedFrame(frame));
342 SerializedPacket serialized_packet = creator_.SerializePacket();
343 ASSERT_TRUE(serialized_packet.packet);
344 delete serialized_packet.packet;
345 delete serialized_packet.retransmittable_frames;
346 }
347 }
348 }
349
TEST_F(QuicPacketCreatorTest,StreamFrameConsumption)350 TEST_F(QuicPacketCreatorTest, StreamFrameConsumption) {
351 // Compute the total overhead for a single frame in packet.
352 const size_t overhead = GetPacketHeaderOverhead() + GetEncryptionOverhead()
353 + GetStreamFrameOverhead();
354 size_t capacity = kDefaultMaxPacketSize - overhead;
355 // Now, test various sizes around this size.
356 for (int delta = -5; delta <= 5; ++delta) {
357 string data(capacity + delta, 'A');
358 size_t bytes_free = delta > 0 ? 0 : 0 - delta;
359 QuicFrame frame;
360 size_t bytes_consumed = creator_.CreateStreamFrame(
361 kStreamId, MakeIOVector(data), kOffset, false, &frame);
362 EXPECT_EQ(capacity - bytes_free, bytes_consumed);
363
364 ASSERT_TRUE(creator_.AddSavedFrame(frame));
365 // BytesFree() returns bytes available for the next frame, which will
366 // be two bytes smaller since the stream frame would need to be grown.
367 size_t expected_bytes_free = bytes_free < 3 ? 0 : bytes_free - 2;
368 EXPECT_EQ(expected_bytes_free, creator_.BytesFree()) << "delta: " << delta;
369 SerializedPacket serialized_packet = creator_.SerializePacket();
370 ASSERT_TRUE(serialized_packet.packet);
371 delete serialized_packet.packet;
372 delete serialized_packet.retransmittable_frames;
373 }
374 }
375
TEST_F(QuicPacketCreatorTest,CryptoStreamFramePacketPadding)376 TEST_F(QuicPacketCreatorTest, CryptoStreamFramePacketPadding) {
377 // Compute the total overhead for a single frame in packet.
378 const size_t overhead = GetPacketHeaderOverhead() + GetEncryptionOverhead()
379 + GetStreamFrameOverhead();
380 ASSERT_GT(kMaxPacketSize, overhead);
381 size_t capacity = kDefaultMaxPacketSize - overhead;
382 // Now, test various sizes around this size.
383 for (int delta = -5; delta <= 5; ++delta) {
384 string data(capacity + delta, 'A');
385 size_t bytes_free = delta > 0 ? 0 : 0 - delta;
386
387 QuicFrame frame;
388 size_t bytes_consumed = creator_.CreateStreamFrame(
389 kStreamId, MakeIOVector(data), kOffset, false, &frame);
390 EXPECT_LT(0u, bytes_consumed);
391 ASSERT_TRUE(creator_.AddSavedFrame(frame));
392 SerializedPacket serialized_packet = creator_.SerializePacket();
393 ASSERT_TRUE(serialized_packet.packet);
394 // If there is not enough space in the packet to fit a padding frame
395 // (1 byte) and to expand the stream frame (another 2 bytes) the packet
396 // will not be padded.
397 if (bytes_free < 3) {
398 EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize)
399 - bytes_free, serialized_packet.packet->length());
400 } else {
401 EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
402 serialized_packet.packet->length());
403 }
404 delete serialized_packet.packet;
405 delete serialized_packet.retransmittable_frames;
406 }
407 }
408
TEST_F(QuicPacketCreatorTest,NonCryptoStreamFramePacketNonPadding)409 TEST_F(QuicPacketCreatorTest, NonCryptoStreamFramePacketNonPadding) {
410 // Compute the total overhead for a single frame in packet.
411 const size_t overhead = GetPacketHeaderOverhead() + GetEncryptionOverhead()
412 + GetStreamFrameOverhead();
413 ASSERT_GT(kDefaultMaxPacketSize, overhead);
414 size_t capacity = kDefaultMaxPacketSize - overhead;
415 // Now, test various sizes around this size.
416 for (int delta = -5; delta <= 5; ++delta) {
417 string data(capacity + delta, 'A');
418 size_t bytes_free = delta > 0 ? 0 : 0 - delta;
419
420 QuicFrame frame;
421 size_t bytes_consumed = creator_.CreateStreamFrame(
422 kStreamId + 2, MakeIOVector(data), kOffset, false, &frame);
423 EXPECT_LT(0u, bytes_consumed);
424 ASSERT_TRUE(creator_.AddSavedFrame(frame));
425 SerializedPacket serialized_packet = creator_.SerializePacket();
426 ASSERT_TRUE(serialized_packet.packet);
427 if (bytes_free > 0) {
428 EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize)
429 - bytes_free, serialized_packet.packet->length());
430 } else {
431 EXPECT_EQ(client_framer_.GetMaxPlaintextSize(kDefaultMaxPacketSize),
432 serialized_packet.packet->length());
433 }
434 delete serialized_packet.packet;
435 delete serialized_packet.retransmittable_frames;
436 }
437 }
438
TEST_F(QuicPacketCreatorTest,SerializeVersionNegotiationPacket)439 TEST_F(QuicPacketCreatorTest, SerializeVersionNegotiationPacket) {
440 QuicPacketCreatorPeer::SetIsServer(&creator_, true);
441 QuicVersionVector versions;
442 versions.push_back(test::QuicVersionMax());
443 scoped_ptr<QuicEncryptedPacket> encrypted(
444 creator_.SerializeVersionNegotiationPacket(versions));
445
446 {
447 InSequence s;
448 EXPECT_CALL(framer_visitor_, OnPacket());
449 EXPECT_CALL(framer_visitor_, OnVersionNegotiationPacket(_));
450 }
451 client_framer_.ProcessPacket(*encrypted.get());
452 }
453
TEST_F(QuicPacketCreatorTest,UpdatePacketSequenceNumberLengthLeastAwaiting)454 TEST_F(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthLeastAwaiting) {
455 EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
456 creator_.options()->send_sequence_number_length);
457
458 creator_.set_sequence_number(64);
459 creator_.UpdateSequenceNumberLength(2, 10000);
460 EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
461 creator_.options()->send_sequence_number_length);
462
463 creator_.set_sequence_number(64 * 256);
464 creator_.UpdateSequenceNumberLength(2, 10000);
465 EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
466 creator_.options()->send_sequence_number_length);
467
468 creator_.set_sequence_number(64 * 256 * 256);
469 creator_.UpdateSequenceNumberLength(2, 10000);
470 EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
471 creator_.options()->send_sequence_number_length);
472
473 creator_.set_sequence_number(GG_UINT64_C(64) * 256 * 256 * 256 * 256);
474 creator_.UpdateSequenceNumberLength(2, 10000);
475 EXPECT_EQ(PACKET_6BYTE_SEQUENCE_NUMBER,
476 creator_.options()->send_sequence_number_length);
477 }
478
TEST_F(QuicPacketCreatorTest,UpdatePacketSequenceNumberLengthBandwidth)479 TEST_F(QuicPacketCreatorTest, UpdatePacketSequenceNumberLengthBandwidth) {
480 EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
481 creator_.options()->send_sequence_number_length);
482
483 creator_.UpdateSequenceNumberLength(1, 10000);
484 EXPECT_EQ(PACKET_1BYTE_SEQUENCE_NUMBER,
485 creator_.options()->send_sequence_number_length);
486
487 creator_.UpdateSequenceNumberLength(1, 10000 * 256);
488 EXPECT_EQ(PACKET_2BYTE_SEQUENCE_NUMBER,
489 creator_.options()->send_sequence_number_length);
490
491 creator_.UpdateSequenceNumberLength(1, 10000 * 256 * 256);
492 EXPECT_EQ(PACKET_4BYTE_SEQUENCE_NUMBER,
493 creator_.options()->send_sequence_number_length);
494
495 creator_.UpdateSequenceNumberLength(
496 1, GG_UINT64_C(1000) * 256 * 256 * 256 * 256);
497 EXPECT_EQ(PACKET_6BYTE_SEQUENCE_NUMBER,
498 creator_.options()->send_sequence_number_length);
499 }
500
TEST_F(QuicPacketCreatorTest,CreateStreamFrameWithNotifier)501 TEST_F(QuicPacketCreatorTest, CreateStreamFrameWithNotifier) {
502 // Ensure that if CreateStreamFrame does not consume any data (e.g. a FIN only
503 // frame) then any QuicAckNotifier that is passed in still gets attached to
504 // the frame.
505 MockAckNotifierDelegate delegate;
506 QuicAckNotifier notifier(&delegate);
507 QuicFrame frame;
508 IOVector empty_iovector;
509 bool fin = true;
510 size_t consumed_bytes = creator_.CreateStreamFrameWithNotifier(
511 1u, empty_iovector, 0u, fin, ¬ifier, &frame);
512 EXPECT_EQ(0u, consumed_bytes);
513 EXPECT_EQ(¬ifier, frame.stream_frame->notifier);
514 delete frame.stream_frame;
515 }
516
517 INSTANTIATE_TEST_CASE_P(ToggleVersionSerialization,
518 QuicPacketCreatorTest,
519 ::testing::Values(false, true));
520
TEST_P(QuicPacketCreatorTest,SerializeFrame)521 TEST_P(QuicPacketCreatorTest, SerializeFrame) {
522 if (!GetParam()) {
523 creator_.StopSendingVersion();
524 }
525 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
526 SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
527 delete frames_[0].stream_frame;
528
529 QuicPacketHeader header;
530 {
531 InSequence s;
532 EXPECT_CALL(framer_visitor_, OnPacket());
533 EXPECT_CALL(framer_visitor_, OnUnauthenticatedHeader(_));
534 EXPECT_CALL(framer_visitor_, OnPacketHeader(_)).WillOnce(
535 DoAll(SaveArg<0>(&header), Return(true)));
536 EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
537 EXPECT_CALL(framer_visitor_, OnPacketComplete());
538 }
539 ProcessPacket(serialized.packet);
540 EXPECT_EQ(GetParam(), header.public_header.version_flag);
541 delete serialized.packet;
542 }
543
TEST_P(QuicPacketCreatorTest,CreateStreamFrameTooLarge)544 TEST_P(QuicPacketCreatorTest, CreateStreamFrameTooLarge) {
545 if (!GetParam()) {
546 creator_.StopSendingVersion();
547 }
548 // A string larger than fits into a frame.
549 size_t payload_length;
550 creator_.options()->max_packet_length = GetPacketLengthForOneStream(
551 client_framer_.version(),
552 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
553 PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP, &payload_length);
554 QuicFrame frame;
555 const string too_long_payload(payload_length * 2, 'a');
556 size_t consumed = creator_.CreateStreamFrame(
557 1u, MakeIOVector(too_long_payload), 0u, true, &frame);
558 EXPECT_EQ(payload_length, consumed);
559 const string payload(payload_length, 'a');
560 CheckStreamFrame(frame, 1u, payload, 0u, false);
561 delete frame.stream_frame;
562 }
563
TEST_P(QuicPacketCreatorTest,AddFrameAndSerialize)564 TEST_P(QuicPacketCreatorTest, AddFrameAndSerialize) {
565 if (!GetParam()) {
566 creator_.StopSendingVersion();
567 }
568 const size_t max_plaintext_size =
569 client_framer_.GetMaxPlaintextSize(creator_.options()->max_packet_length);
570 EXPECT_FALSE(creator_.HasPendingFrames());
571 EXPECT_EQ(max_plaintext_size -
572 GetPacketHeaderSize(
573 creator_.options()->send_guid_length,
574 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
575 PACKET_1BYTE_SEQUENCE_NUMBER, NOT_IN_FEC_GROUP),
576 creator_.BytesFree());
577
578 // Add a variety of frame types and then a padding frame.
579 QuicAckFrame ack_frame(0u, QuicTime::Zero(), 0u);
580 EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
581 EXPECT_TRUE(creator_.HasPendingFrames());
582
583 QuicCongestionFeedbackFrame congestion_feedback;
584 congestion_feedback.type = kFixRate;
585 EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&congestion_feedback)));
586 EXPECT_TRUE(creator_.HasPendingFrames());
587
588 QuicFrame frame;
589 size_t consumed = creator_.CreateStreamFrame(
590 1u, MakeIOVector("test"), 0u, false, &frame);
591 EXPECT_EQ(4u, consumed);
592 ASSERT_TRUE(frame.stream_frame);
593 EXPECT_TRUE(creator_.AddSavedFrame(frame));
594 EXPECT_TRUE(creator_.HasPendingFrames());
595
596 QuicPaddingFrame padding_frame;
597 EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&padding_frame)));
598 EXPECT_TRUE(creator_.HasPendingFrames());
599 EXPECT_EQ(0u, creator_.BytesFree());
600
601 EXPECT_FALSE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
602
603 // Ensure the packet is successfully created.
604 SerializedPacket serialized = creator_.SerializePacket();
605 ASSERT_TRUE(serialized.packet);
606 delete serialized.packet;
607 ASSERT_TRUE(serialized.retransmittable_frames);
608 RetransmittableFrames* retransmittable = serialized.retransmittable_frames;
609 ASSERT_EQ(1u, retransmittable->frames().size());
610 EXPECT_EQ(STREAM_FRAME, retransmittable->frames()[0].type);
611 ASSERT_TRUE(retransmittable->frames()[0].stream_frame);
612 delete serialized.retransmittable_frames;
613
614 EXPECT_FALSE(creator_.HasPendingFrames());
615 EXPECT_EQ(max_plaintext_size -
616 GetPacketHeaderSize(
617 creator_.options()->send_guid_length,
618 QuicPacketCreatorPeer::SendVersionInPacket(&creator_),
619 PACKET_1BYTE_SEQUENCE_NUMBER,
620 NOT_IN_FEC_GROUP),
621 creator_.BytesFree());
622 }
623
TEST_F(QuicPacketCreatorTest,EntropyFlag)624 TEST_F(QuicPacketCreatorTest, EntropyFlag) {
625 frames_.push_back(QuicFrame(new QuicStreamFrame(0u, false, 0u, IOVector())));
626
627 for (int i = 0; i < 2; ++i) {
628 for (int j = 0; j < 64; ++j) {
629 SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
630 // Verify both BoolSource and hash algorithm.
631 bool expected_rand_bool =
632 (mock_random_.RandUint64() & (GG_UINT64_C(1) << j)) != 0;
633 bool observed_rand_bool =
634 (serialized.entropy_hash & (1 << ((j+1) % 8))) != 0;
635 uint8 rest_of_hash = serialized.entropy_hash & ~(1 << ((j+1) % 8));
636 EXPECT_EQ(expected_rand_bool, observed_rand_bool);
637 EXPECT_EQ(0, rest_of_hash);
638 delete serialized.packet;
639 }
640 // After 64 calls, BoolSource will refresh the bucket - make sure it does.
641 mock_random_.ChangeValue();
642 }
643
644 delete frames_[0].stream_frame;
645 }
646
647 } // namespace
648 } // namespace test
649 } // namespace net
650