src/net/quic/quic_packet_creator_test.cc

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