net/quic/quic_packet_generator_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_generator.h"
   6
   7 #include <string>
   8
   9 #include "net/quic/crypto/crypto_protocol.h"
  10 #include "net/quic/crypto/null_encrypter.h"
  11 #include "net/quic/crypto/quic_decrypter.h"
  12 #include "net/quic/crypto/quic_encrypter.h"
  13 #include "net/quic/quic_utils.h"
  14 #include "net/quic/test_tools/quic_packet_creator_peer.h"
  15 #include "net/quic/test_tools/quic_packet_generator_peer.h"
  16 #include "net/quic/test_tools/quic_test_utils.h"
  17 #include "net/quic/test_tools/simple_quic_framer.h"
  18 #include "testing/gmock/include/gmock/gmock.h"
  19 #include "testing/gtest/include/gtest/gtest.h"
  20
  21 using base::StringPiece;
  22 using std::string;
  23 using testing::InSequence;
  24 using testing::Return;
  25 using testing::SaveArg;
  26 using testing::StrictMock;
  27 using testing::_;
  28
  29 namespace net {
  30 namespace test {
  31 namespace {
  32
  33 class MockDelegate : public QuicPacketGenerator::DelegateInterface {
  34  public:
  35   MockDelegate() {}
  36   ~MockDelegate() override {}
  37
  38   MOCK_METHOD3(ShouldGeneratePacket,
  39                bool(TransmissionType transmission_type,
  40                     HasRetransmittableData retransmittable,
  41                     IsHandshake handshake));
  42   MOCK_METHOD0(CreateAckFrame, QuicAckFrame*());
  43   MOCK_METHOD0(CreateFeedbackFrame, QuicCongestionFeedbackFrame*());
  44   MOCK_METHOD0(CreateStopWaitingFrame, QuicStopWaitingFrame*());
  45   MOCK_METHOD1(OnSerializedPacket, void(const SerializedPacket& packet));
  46   MOCK_METHOD2(CloseConnection, void(QuicErrorCode, bool));
  47
  48   void SetCanWriteAnything() {
  49     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION, _, _))
  50         .WillRepeatedly(Return(true));
  51     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION,
  52                                             NO_RETRANSMITTABLE_DATA, _))
  53         .WillRepeatedly(Return(true));
  54   }
  55
  56   void SetCanNotWrite() {
  57     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION, _, _))
  58         .WillRepeatedly(Return(false));
  59     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION,
  60                                             NO_RETRANSMITTABLE_DATA, _))
  61         .WillRepeatedly(Return(false));
  62   }
  63
  64   // Use this when only ack and feedback frames should be allowed to be written.
  65   void SetCanWriteOnlyNonRetransmittable() {
  66     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION, _, _))
  67         .WillRepeatedly(Return(false));
  68     EXPECT_CALL(*this, ShouldGeneratePacket(NOT_RETRANSMISSION,
  69                                             NO_RETRANSMITTABLE_DATA, _))
  70         .WillRepeatedly(Return(true));
  71   }
  72
  73  private:
  74   DISALLOW_COPY_AND_ASSIGN(MockDelegate);
  75 };
  76
  77 // Simple struct for describing the contents of a packet.
  78 // Useful in conjunction with a SimpleQuicFrame for validating
  79 // that a packet contains the expected frames.
  80 struct PacketContents {
  81   PacketContents()
  82       : num_ack_frames(0),
  83         num_connection_close_frames(0),
  84         num_feedback_frames(0),
  85         num_goaway_frames(0),
  86         num_rst_stream_frames(0),
  87         num_stop_waiting_frames(0),
  88         num_stream_frames(0),
  89         fec_group(0) {
  90   }
  91
  92   size_t num_ack_frames;
  93   size_t num_connection_close_frames;
  94   size_t num_feedback_frames;
  95   size_t num_goaway_frames;
  96   size_t num_rst_stream_frames;
  97   size_t num_stop_waiting_frames;
  98   size_t num_stream_frames;
  99
 100   QuicFecGroupNumber fec_group;
 101 };
 102
 103 }  // namespace
 104
 105 class QuicPacketGeneratorTest : public ::testing::Test {
 106  protected:
 107   QuicPacketGeneratorTest()
 108       : framer_(QuicSupportedVersions(), QuicTime::Zero(), false),
 109         generator_(42, &framer_, &random_, &delegate_),
 110         creator_(QuicPacketGeneratorPeer::GetPacketCreator(&generator_)),
 111         packet_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr),
 112         packet2_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr),
 113         packet3_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr),
 114         packet4_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr),
 115         packet5_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr),
 116         packet6_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr),
 117         packet7_(0, PACKET_1BYTE_SEQUENCE_NUMBER, nullptr, 0, nullptr) {}
 118
 119   ~QuicPacketGeneratorTest() override {
 120     delete packet_.packet;
 121     delete packet_.retransmittable_frames;
 122     delete packet2_.packet;
 123     delete packet2_.retransmittable_frames;
 124     delete packet3_.packet;
 125     delete packet3_.retransmittable_frames;
 126     delete packet4_.packet;
 127     delete packet4_.retransmittable_frames;
 128     delete packet5_.packet;
 129     delete packet5_.retransmittable_frames;
 130     delete packet6_.packet;
 131     delete packet6_.retransmittable_frames;
 132     delete packet7_.packet;
 133     delete packet7_.retransmittable_frames;
 134   }
 135
 136   QuicAckFrame* CreateAckFrame() {
 137     // TODO(rch): Initialize this so it can be verified later.
 138     return new QuicAckFrame(MakeAckFrame(0));
 139   }
 140
 141   QuicCongestionFeedbackFrame* CreateFeedbackFrame() {
 142     QuicCongestionFeedbackFrame* frame = new QuicCongestionFeedbackFrame;
 143     frame->type = kTCP;
 144     frame->tcp.receive_window = 0x4030;
 145     return frame;
 146   }
 147
 148   QuicStopWaitingFrame* CreateStopWaitingFrame() {
 149     QuicStopWaitingFrame* frame = new QuicStopWaitingFrame();
 150     frame->entropy_hash = 0;
 151     frame->least_unacked = 0;
 152     return frame;
 153   }
 154
 155   QuicRstStreamFrame* CreateRstStreamFrame() {
 156     return new QuicRstStreamFrame(1, QUIC_STREAM_NO_ERROR, 0);
 157   }
 158
 159   QuicGoAwayFrame* CreateGoAwayFrame() {
 160     return new QuicGoAwayFrame(QUIC_NO_ERROR, 1, string());
 161   }
 162
 163   void CheckPacketContains(const PacketContents& contents,
 164                            const SerializedPacket& packet) {
 165     size_t num_retransmittable_frames = contents.num_connection_close_frames +
 166         contents.num_goaway_frames + contents.num_rst_stream_frames +
 167         contents.num_stream_frames;
 168     size_t num_frames = contents.num_feedback_frames + contents.num_ack_frames +
 169         contents.num_stop_waiting_frames + num_retransmittable_frames;
 170
 171     if (num_retransmittable_frames == 0) {
 172       ASSERT_TRUE(packet.retransmittable_frames == nullptr);
 173     } else {
 174       ASSERT_TRUE(packet.retransmittable_frames != nullptr);
 175       EXPECT_EQ(num_retransmittable_frames,
 176                 packet.retransmittable_frames->frames().size());
 177     }
 178
 179     ASSERT_TRUE(packet.packet != nullptr);
 180     ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
 181     EXPECT_EQ(num_frames, simple_framer_.num_frames());
 182     EXPECT_EQ(contents.num_ack_frames, simple_framer_.ack_frames().size());
 183     EXPECT_EQ(contents.num_connection_close_frames,
 184               simple_framer_.connection_close_frames().size());
 185     EXPECT_EQ(contents.num_feedback_frames,
 186               simple_framer_.feedback_frames().size());
 187     EXPECT_EQ(contents.num_goaway_frames,
 188               simple_framer_.goaway_frames().size());
 189     EXPECT_EQ(contents.num_rst_stream_frames,
 190               simple_framer_.rst_stream_frames().size());
 191     EXPECT_EQ(contents.num_stream_frames,
 192               simple_framer_.stream_frames().size());
 193     EXPECT_EQ(contents.num_stop_waiting_frames,
 194               simple_framer_.stop_waiting_frames().size());
 195     EXPECT_EQ(contents.fec_group, simple_framer_.header().fec_group);
 196   }
 197
 198   void CheckPacketHasSingleStreamFrame(const SerializedPacket& packet) {
 199     ASSERT_TRUE(packet.retransmittable_frames != nullptr);
 200     EXPECT_EQ(1u, packet.retransmittable_frames->frames().size());
 201     ASSERT_TRUE(packet.packet != nullptr);
 202     ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
 203     EXPECT_EQ(1u, simple_framer_.num_frames());
 204     EXPECT_EQ(1u, simple_framer_.stream_frames().size());
 205   }
 206
 207   void CheckPacketIsFec(const SerializedPacket& packet,
 208                         QuicPacketSequenceNumber fec_group) {
 209     ASSERT_TRUE(packet.retransmittable_frames == nullptr);
 210     ASSERT_TRUE(packet.packet != nullptr);
 211     ASSERT_TRUE(simple_framer_.ProcessPacket(*packet.packet));
 212     EXPECT_TRUE(simple_framer_.header().fec_flag);
 213     EXPECT_EQ(fec_group, simple_framer_.fec_data().fec_group);
 214   }
 215
 216   IOVector CreateData(size_t len) {
 217     data_array_.reset(new char[len]);
 218     memset(data_array_.get(), '?', len);
 219     IOVector data;
 220     data.Append(data_array_.get(), len);
 221     return data;
 222   }
 223
 224   QuicFramer framer_;
 225   MockRandom random_;
 226   StrictMock<MockDelegate> delegate_;
 227   QuicPacketGenerator generator_;
 228   QuicPacketCreator* creator_;
 229   SimpleQuicFramer simple_framer_;
 230   SerializedPacket packet_;
 231   SerializedPacket packet2_;
 232   SerializedPacket packet3_;
 233   SerializedPacket packet4_;
 234   SerializedPacket packet5_;
 235   SerializedPacket packet6_;
 236   SerializedPacket packet7_;
 237
 238  private:
 239   scoped_ptr<char[]> data_array_;
 240 };
 241
 242 class MockDebugDelegate : public QuicPacketGenerator::DebugDelegate {
 243  public:
 244   MOCK_METHOD1(OnFrameAddedToPacket,
 245                void(const QuicFrame&));
 246 };
 247
 248 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_NotWritable) {
 249   delegate_.SetCanNotWrite();
 250
 251   generator_.SetShouldSendAck(false, false);
 252   EXPECT_TRUE(generator_.HasQueuedFrames());
 253 }
 254
 255 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldNotFlush) {
 256   StrictMock<MockDebugDelegate> debug_delegate;
 257
 258   generator_.set_debug_delegate(&debug_delegate);
 259   delegate_.SetCanWriteOnlyNonRetransmittable();
 260   generator_.StartBatchOperations();
 261
 262   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 263   EXPECT_CALL(debug_delegate, OnFrameAddedToPacket(_)).Times(1);
 264
 265   generator_.SetShouldSendAck(false, false);
 266   EXPECT_TRUE(generator_.HasQueuedFrames());
 267 }
 268
 269 TEST_F(QuicPacketGeneratorTest, ShouldSendAck_WritableAndShouldFlush) {
 270   delegate_.SetCanWriteOnlyNonRetransmittable();
 271
 272   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 273   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
 274
 275   generator_.SetShouldSendAck(false, false);
 276   EXPECT_FALSE(generator_.HasQueuedFrames());
 277
 278   PacketContents contents;
 279   contents.num_ack_frames = 1;
 280   CheckPacketContains(contents, packet_);
 281 }
 282
 283 TEST_F(QuicPacketGeneratorTest,
 284        ShouldSendAckWithFeedback_WritableAndShouldNotFlush) {
 285   delegate_.SetCanWriteOnlyNonRetransmittable();
 286   generator_.StartBatchOperations();
 287
 288   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 289   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
 290       Return(CreateFeedbackFrame()));
 291
 292   generator_.SetShouldSendAck(true, false);
 293   EXPECT_TRUE(generator_.HasQueuedFrames());
 294 }
 295
 296 TEST_F(QuicPacketGeneratorTest,
 297        ShouldSendAckWithFeedback_WritableAndShouldFlush) {
 298   delegate_.SetCanWriteOnlyNonRetransmittable();
 299
 300   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 301   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
 302       Return(CreateFeedbackFrame()));
 303   EXPECT_CALL(delegate_, CreateStopWaitingFrame()).WillOnce(
 304       Return(CreateStopWaitingFrame()));
 305
 306   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
 307
 308   generator_.SetShouldSendAck(true, true);
 309   EXPECT_FALSE(generator_.HasQueuedFrames());
 310
 311   PacketContents contents;
 312   contents.num_ack_frames = 1;
 313   contents.num_feedback_frames = 1;
 314   contents.num_stop_waiting_frames = 1;
 315   CheckPacketContains(contents, packet_);
 316 }
 317
 318 TEST_F(QuicPacketGeneratorTest, AddControlFrame_NotWritable) {
 319   delegate_.SetCanNotWrite();
 320
 321   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 322   EXPECT_TRUE(generator_.HasQueuedFrames());
 323 }
 324
 325 TEST_F(QuicPacketGeneratorTest, AddControlFrame_OnlyAckWritable) {
 326   delegate_.SetCanWriteOnlyNonRetransmittable();
 327
 328   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 329   EXPECT_TRUE(generator_.HasQueuedFrames());
 330 }
 331
 332 TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldNotFlush) {
 333   delegate_.SetCanWriteAnything();
 334   generator_.StartBatchOperations();
 335
 336   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 337   EXPECT_TRUE(generator_.HasQueuedFrames());
 338 }
 339
 340 TEST_F(QuicPacketGeneratorTest, AddControlFrame_NotWritableBatchThenFlush) {
 341   delegate_.SetCanNotWrite();
 342   generator_.StartBatchOperations();
 343
 344   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 345   EXPECT_TRUE(generator_.HasQueuedFrames());
 346   generator_.FinishBatchOperations();
 347   EXPECT_TRUE(generator_.HasQueuedFrames());
 348
 349   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
 350   generator_.FlushAllQueuedFrames();
 351   EXPECT_FALSE(generator_.HasQueuedFrames());
 352
 353   PacketContents contents;
 354   contents.num_rst_stream_frames = 1;
 355   CheckPacketContains(contents, packet_);
 356 }
 357
 358 TEST_F(QuicPacketGeneratorTest, AddControlFrame_WritableAndShouldFlush) {
 359   delegate_.SetCanWriteAnything();
 360
 361   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
 362
 363   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 364   EXPECT_FALSE(generator_.HasQueuedFrames());
 365
 366   PacketContents contents;
 367   contents.num_rst_stream_frames = 1;
 368   CheckPacketContains(contents, packet_);
 369 }
 370
 371 TEST_F(QuicPacketGeneratorTest, ConsumeData_NotWritable) {
 372   delegate_.SetCanNotWrite();
 373
 374   QuicConsumedData consumed = generator_.ConsumeData(
 375       kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, nullptr);
 376   EXPECT_EQ(0u, consumed.bytes_consumed);
 377   EXPECT_FALSE(consumed.fin_consumed);
 378   EXPECT_FALSE(generator_.HasQueuedFrames());
 379 }
 380
 381 TEST_F(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldNotFlush) {
 382   delegate_.SetCanWriteAnything();
 383   generator_.StartBatchOperations();
 384
 385   QuicConsumedData consumed = generator_.ConsumeData(
 386       kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, nullptr);
 387   EXPECT_EQ(3u, consumed.bytes_consumed);
 388   EXPECT_TRUE(consumed.fin_consumed);
 389   EXPECT_TRUE(generator_.HasQueuedFrames());
 390 }
 391
 392 TEST_F(QuicPacketGeneratorTest, ConsumeData_WritableAndShouldFlush) {
 393   delegate_.SetCanWriteAnything();
 394
 395   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
 396   QuicConsumedData consumed = generator_.ConsumeData(
 397       kHeadersStreamId, MakeIOVector("foo"), 2, true, MAY_FEC_PROTECT, nullptr);
 398   EXPECT_EQ(3u, consumed.bytes_consumed);
 399   EXPECT_TRUE(consumed.fin_consumed);
 400   EXPECT_FALSE(generator_.HasQueuedFrames());
 401
 402   PacketContents contents;
 403   contents.num_stream_frames = 1;
 404   CheckPacketContains(contents, packet_);
 405 }
 406
 407 TEST_F(QuicPacketGeneratorTest,
 408        ConsumeDataMultipleTimes_WritableAndShouldNotFlush) {
 409   delegate_.SetCanWriteAnything();
 410   generator_.StartBatchOperations();
 411
 412   generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true,
 413                          MAY_FEC_PROTECT, nullptr);
 414   QuicConsumedData consumed = generator_.ConsumeData(
 415       3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, nullptr);
 416   EXPECT_EQ(4u, consumed.bytes_consumed);
 417   EXPECT_FALSE(consumed.fin_consumed);
 418   EXPECT_TRUE(generator_.HasQueuedFrames());
 419 }
 420
 421 TEST_F(QuicPacketGeneratorTest, ConsumeData_BatchOperations) {
 422   delegate_.SetCanWriteAnything();
 423   generator_.StartBatchOperations();
 424
 425   generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 2, true,
 426                          MAY_FEC_PROTECT, nullptr);
 427   QuicConsumedData consumed = generator_.ConsumeData(
 428       3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT, nullptr);
 429   EXPECT_EQ(4u, consumed.bytes_consumed);
 430   EXPECT_FALSE(consumed.fin_consumed);
 431   EXPECT_TRUE(generator_.HasQueuedFrames());
 432
 433   // Now both frames will be flushed out.
 434   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
 435   generator_.FinishBatchOperations();
 436   EXPECT_FALSE(generator_.HasQueuedFrames());
 437
 438   PacketContents contents;
 439   contents.num_stream_frames = 2;
 440   CheckPacketContains(contents, packet_);
 441 }
 442
 443 TEST_F(QuicPacketGeneratorTest, ConsumeDataFEC) {
 444   delegate_.SetCanWriteAnything();
 445
 446   // Send FEC every two packets.
 447   creator_->set_max_packets_per_fec_group(2);
 448
 449   {
 450     InSequence dummy;
 451     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 452         SaveArg<0>(&packet_));
 453     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 454         SaveArg<0>(&packet2_));
 455     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 456         SaveArg<0>(&packet3_));
 457     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 458         SaveArg<0>(&packet4_));
 459     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 460         SaveArg<0>(&packet5_));
 461   }
 462
 463   // Send enough data to create 3 packets: two full and one partial. Send
 464   // with MUST_FEC_PROTECT flag.
 465   size_t data_len = 2 * kDefaultMaxPacketSize + 100;
 466   QuicConsumedData consumed = generator_.ConsumeData(
 467       3, CreateData(data_len), 0, true, MUST_FEC_PROTECT, nullptr);
 468   EXPECT_EQ(data_len, consumed.bytes_consumed);
 469   EXPECT_TRUE(consumed.fin_consumed);
 470   EXPECT_FALSE(generator_.HasQueuedFrames());
 471
 472   CheckPacketHasSingleStreamFrame(packet_);
 473   CheckPacketHasSingleStreamFrame(packet2_);
 474   CheckPacketIsFec(packet3_, 1);
 475
 476   CheckPacketHasSingleStreamFrame(packet4_);
 477   CheckPacketIsFec(packet5_, 4);
 478 }
 479
 480 TEST_F(QuicPacketGeneratorTest, ConsumeDataSendsFecAtEnd) {
 481   delegate_.SetCanWriteAnything();
 482
 483   // Enable FEC.
 484   creator_->set_max_packets_per_fec_group(6);
 485   {
 486     InSequence dummy;
 487     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 488         SaveArg<0>(&packet_));
 489     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 490         SaveArg<0>(&packet2_));
 491     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 492         SaveArg<0>(&packet3_));
 493   }
 494
 495   // Send enough data to create 2 packets: one full and one partial. Send
 496   // with MUST_FEC_PROTECT flag.
 497   size_t data_len = 1 * kDefaultMaxPacketSize + 100;
 498   QuicConsumedData consumed = generator_.ConsumeData(
 499       3, CreateData(data_len), 0, true, MUST_FEC_PROTECT, nullptr);
 500   EXPECT_EQ(data_len, consumed.bytes_consumed);
 501   EXPECT_TRUE(consumed.fin_consumed);
 502   EXPECT_FALSE(generator_.HasQueuedFrames());
 503
 504   CheckPacketHasSingleStreamFrame(packet_);
 505   CheckPacketHasSingleStreamFrame(packet2_);
 506   CheckPacketIsFec(packet3_, 1);
 507 }
 508
 509 TEST_F(QuicPacketGeneratorTest, ConsumeData_FramesPreviouslyQueued) {
 510   // Set the packet size be enough for two stream frames with 0 stream offset,
 511   // but not enough for a stream frame of 0 offset and one with non-zero offset.
 512   size_t length =
 513       NullEncrypter().GetCiphertextSize(0) +
 514       GetPacketHeaderSize(creator_->connection_id_length(),
 515                           true,
 516                           creator_->next_sequence_number_length(),
 517                           NOT_IN_FEC_GROUP) +
 518       // Add an extra 3 bytes for the payload and 1 byte so BytesFree is larger
 519       // than the GetMinStreamFrameSize.
 520       QuicFramer::GetMinStreamFrameSize(1, 0, false, NOT_IN_FEC_GROUP) + 3 +
 521       QuicFramer::GetMinStreamFrameSize(1, 0, true, NOT_IN_FEC_GROUP) + 1;
 522   creator_->set_max_packet_length(length);
 523   delegate_.SetCanWriteAnything();
 524   {
 525      InSequence dummy;
 526      EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 527          SaveArg<0>(&packet_));
 528      EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 529          SaveArg<0>(&packet2_));
 530   }
 531   generator_.StartBatchOperations();
 532   // Queue enough data to prevent a stream frame with a non-zero offset from
 533   // fitting.
 534   QuicConsumedData consumed =
 535       generator_.ConsumeData(kHeadersStreamId, MakeIOVector("foo"), 0, false,
 536                              MAY_FEC_PROTECT, nullptr);
 537   EXPECT_EQ(3u, consumed.bytes_consumed);
 538   EXPECT_FALSE(consumed.fin_consumed);
 539   EXPECT_TRUE(generator_.HasQueuedFrames());
 540
 541   // This frame will not fit with the existing frame, causing the queued frame
 542   // to be serialized, and it will not fit with another frame like it, so it is
 543   // serialized by itself.
 544   consumed = generator_.ConsumeData(kHeadersStreamId, MakeIOVector("bar"), 3,
 545                                     true, MAY_FEC_PROTECT, nullptr);
 546   EXPECT_EQ(3u, consumed.bytes_consumed);
 547   EXPECT_TRUE(consumed.fin_consumed);
 548   EXPECT_FALSE(generator_.HasQueuedFrames());
 549
 550   PacketContents contents;
 551   contents.num_stream_frames = 1;
 552   CheckPacketContains(contents, packet_);
 553   CheckPacketContains(contents, packet2_);
 554 }
 555
 556 TEST_F(QuicPacketGeneratorTest, FecGroupSizeOnCongestionWindowChange) {
 557   delegate_.SetCanWriteAnything();
 558   creator_->set_max_packets_per_fec_group(50);
 559   EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
 560   EXPECT_FALSE(creator_->IsFecGroupOpen());
 561
 562   // On reduced cwnd.
 563   generator_.OnCongestionWindowChange(7);
 564   EXPECT_EQ(3u, creator_->max_packets_per_fec_group());
 565
 566   // On increased cwnd.
 567   generator_.OnCongestionWindowChange(100);
 568   EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
 569
 570   // On collapsed cwnd.
 571   generator_.OnCongestionWindowChange(1);
 572   EXPECT_EQ(2u, creator_->max_packets_per_fec_group());
 573 }
 574
 575 TEST_F(QuicPacketGeneratorTest, FecGroupSizeChangeWithOpenGroup) {
 576   delegate_.SetCanWriteAnything();
 577   // TODO(jri): This starting of batch mode should not be required when
 578   // FEC sending is separated from batching operations.
 579   generator_.StartBatchOperations();
 580   creator_->set_max_packets_per_fec_group(50);
 581   EXPECT_EQ(50u, creator_->max_packets_per_fec_group());
 582   EXPECT_FALSE(creator_->IsFecGroupOpen());
 583
 584   // Send enough data to create 4 packets with MUST_FEC_PROTECT flag.
 585   // 3 packets are sent, one is queued in the creator.
 586   {
 587     InSequence dummy;
 588     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 589         SaveArg<0>(&packet_));
 590     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 591         SaveArg<0>(&packet2_));
 592     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 593         SaveArg<0>(&packet3_));
 594   }
 595   size_t data_len = 3 * kDefaultMaxPacketSize + 1;
 596   QuicConsumedData consumed = generator_.ConsumeData(
 597       7, CreateData(data_len), 0, true, MUST_FEC_PROTECT, nullptr);
 598   EXPECT_EQ(data_len, consumed.bytes_consumed);
 599   EXPECT_TRUE(creator_->IsFecGroupOpen());
 600
 601   // Change FEC groupsize.
 602   generator_.OnCongestionWindowChange(2);
 603   EXPECT_EQ(2u, creator_->max_packets_per_fec_group());
 604
 605   // Send enough data to trigger one unprotected data packet,
 606   // causing the FEC packet to also be sent.
 607   {
 608     InSequence dummy;
 609     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 610         SaveArg<0>(&packet4_));
 611     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 612         SaveArg<0>(&packet5_));
 613   }
 614   consumed = generator_.ConsumeData(7, CreateData(kDefaultMaxPacketSize), 0,
 615                                     true, MAY_FEC_PROTECT, nullptr);
 616   EXPECT_EQ(kDefaultMaxPacketSize, consumed.bytes_consumed);
 617   // Verify that one FEC packet was sent.
 618   CheckPacketIsFec(packet5_, /*fec_group=*/1u);
 619   EXPECT_FALSE(creator_->IsFecGroupOpen());
 620   EXPECT_FALSE(creator_->IsFecProtected());
 621 }
 622
 623 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOff) {
 624   delegate_.SetCanWriteAnything();
 625   creator_->set_max_packets_per_fec_group(2);
 626   EXPECT_FALSE(creator_->IsFecProtected());
 627
 628   // Send one unprotected data packet.
 629   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 630         SaveArg<0>(&packet_));
 631   QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
 632                                                      MAY_FEC_PROTECT, nullptr);
 633   EXPECT_EQ(1u, consumed.bytes_consumed);
 634   EXPECT_FALSE(generator_.HasQueuedFrames());
 635   EXPECT_FALSE(creator_->IsFecProtected());
 636   // Verify that one data packet was sent.
 637   PacketContents contents;
 638   contents.num_stream_frames = 1;
 639   CheckPacketContains(contents, packet_);
 640
 641   {
 642     InSequence dummy;
 643     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 644         SaveArg<0>(&packet2_));
 645     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 646         SaveArg<0>(&packet3_));
 647     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 648         SaveArg<0>(&packet4_));
 649     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 650         SaveArg<0>(&packet5_));
 651     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 652         SaveArg<0>(&packet6_));
 653   }
 654   // Send enough data to create 3 packets with MUST_FEC_PROTECT flag.
 655   size_t data_len = 2 * kDefaultMaxPacketSize + 100;
 656   consumed = generator_.ConsumeData(7, CreateData(data_len), 0, true,
 657                                     MUST_FEC_PROTECT, nullptr);
 658   EXPECT_EQ(data_len, consumed.bytes_consumed);
 659   EXPECT_FALSE(generator_.HasQueuedFrames());
 660
 661   // Verify that two FEC packets were sent.
 662   CheckPacketHasSingleStreamFrame(packet2_);
 663   CheckPacketHasSingleStreamFrame(packet3_);
 664   CheckPacketIsFec(packet4_, /*fec_group=*/2u);
 665   CheckPacketHasSingleStreamFrame(packet5_);
 666   CheckPacketIsFec(packet6_, /*fec_group=*/5u);  // Sent at the end of stream.
 667
 668   // Send one unprotected data packet.
 669   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 670         SaveArg<0>(&packet7_));
 671   consumed = generator_.ConsumeData(7, CreateData(1u), 0, true, MAY_FEC_PROTECT,
 672                                     nullptr);
 673   EXPECT_EQ(1u, consumed.bytes_consumed);
 674   EXPECT_FALSE(generator_.HasQueuedFrames());
 675   EXPECT_FALSE(creator_->IsFecProtected());
 676   // Verify that one unprotected data packet was sent.
 677   CheckPacketContains(contents, packet7_);
 678 }
 679
 680 TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFrameInCreator) {
 681   delegate_.SetCanWriteAnything();
 682   // Enable FEC.
 683   creator_->set_max_packets_per_fec_group(2);
 684
 685   generator_.StartBatchOperations();
 686   // Queue enough data to prevent a stream frame with a non-zero offset from
 687   // fitting.
 688   QuicConsumedData consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
 689                                                      MAY_FEC_PROTECT, nullptr);
 690   EXPECT_EQ(1u, consumed.bytes_consumed);
 691   EXPECT_TRUE(creator_->HasPendingFrames());
 692
 693   // Queue protected data for sending. Should cause queued frames to be flushed.
 694   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 695       SaveArg<0>(&packet_));
 696   EXPECT_FALSE(creator_->IsFecProtected());
 697   consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
 698                                     MUST_FEC_PROTECT, nullptr);
 699   EXPECT_EQ(1u, consumed.bytes_consumed);
 700   PacketContents contents;
 701   contents.num_stream_frames = 1;
 702   // Transmitted packet was not FEC protected.
 703   CheckPacketContains(contents, packet_);
 704   EXPECT_TRUE(creator_->IsFecProtected());
 705   EXPECT_TRUE(creator_->HasPendingFrames());
 706 }
 707
 708 TEST_F(QuicPacketGeneratorTest, SwitchFecOnWithPendingFramesInGenerator) {
 709   // Enable FEC.
 710   creator_->set_max_packets_per_fec_group(2);
 711
 712   // Queue control frames in generator.
 713   delegate_.SetCanNotWrite();
 714   generator_.SetShouldSendAck(true, true);
 715   delegate_.SetCanWriteAnything();
 716   generator_.StartBatchOperations();
 717
 718   // Set up frames to write into the creator when control frames are written.
 719   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 720   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
 721       Return(CreateFeedbackFrame()));
 722   EXPECT_CALL(delegate_, CreateStopWaitingFrame()).WillOnce(
 723       Return(CreateStopWaitingFrame()));
 724
 725   // Generator should have queued control frames, and creator should be empty.
 726   EXPECT_TRUE(generator_.HasQueuedFrames());
 727   EXPECT_FALSE(creator_->HasPendingFrames());
 728   EXPECT_FALSE(creator_->IsFecProtected());
 729
 730   // Queue protected data for sending. Should cause queued frames to be flushed.
 731   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 732       SaveArg<0>(&packet_));
 733   QuicConsumedData consumed = generator_.ConsumeData(7, CreateData(1u), 0, true,
 734                                                      MUST_FEC_PROTECT, nullptr);
 735   EXPECT_EQ(1u, consumed.bytes_consumed);
 736   PacketContents contents;
 737   contents.num_ack_frames = 1;
 738   contents.num_feedback_frames = 1;
 739   contents.num_stop_waiting_frames = 1;
 740   CheckPacketContains(contents, packet_);
 741
 742   // FEC protection should be on in creator.
 743   EXPECT_TRUE(creator_->IsFecProtected());
 744 }
 745
 746 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentFramesProtected) {
 747   delegate_.SetCanWriteAnything();
 748
 749   // Enable FEC.
 750   creator_->set_max_packets_per_fec_group(2);
 751   EXPECT_FALSE(creator_->IsFecProtected());
 752
 753   // Queue stream frame to be protected in creator.
 754   generator_.StartBatchOperations();
 755   QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
 756                                                      MUST_FEC_PROTECT, nullptr);
 757   EXPECT_EQ(1u, consumed.bytes_consumed);
 758   // Creator has a pending protected frame.
 759   EXPECT_TRUE(creator_->HasPendingFrames());
 760   EXPECT_TRUE(creator_->IsFecProtected());
 761
 762   // Add enough unprotected data to exceed size of current packet, so that
 763   // current packet is sent. Both frames will be sent out in a single packet.
 764   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
 765   size_t data_len = kDefaultMaxPacketSize;
 766   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
 767                                     MAY_FEC_PROTECT, nullptr);
 768   EXPECT_EQ(data_len, consumed.bytes_consumed);
 769   PacketContents contents;
 770   contents.num_stream_frames = 2u;
 771   contents.fec_group = 1u;
 772   CheckPacketContains(contents, packet_);
 773   // FEC protection should still be on in creator.
 774   EXPECT_TRUE(creator_->IsFecProtected());
 775 }
 776
 777 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffWithSubsequentPacketsProtected) {
 778   delegate_.SetCanWriteAnything();
 779
 780   // Enable FEC.
 781   creator_->set_max_packets_per_fec_group(2);
 782   EXPECT_FALSE(creator_->IsFecProtected());
 783
 784   generator_.StartBatchOperations();
 785   // Send first packet, FEC protected.
 786   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
 787   // Write enough data to cause a packet to be emitted.
 788   size_t data_len = kDefaultMaxPacketSize;
 789   QuicConsumedData consumed = generator_.ConsumeData(
 790       5, CreateData(data_len), 0, true, MUST_FEC_PROTECT, nullptr);
 791   EXPECT_EQ(data_len, consumed.bytes_consumed);
 792   PacketContents contents;
 793   contents.num_stream_frames = 1u;
 794   contents.fec_group = 1u;
 795   CheckPacketContains(contents, packet_);
 796
 797   // FEC should still be on in creator.
 798   EXPECT_TRUE(creator_->IsFecProtected());
 799
 800   // Send enough unprotected data to cause second packet to be sent, which gets
 801   // protected because it happens to fall within an open FEC group. Data packet
 802   // will be followed by FEC packet.
 803   {
 804     InSequence dummy;
 805     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 806         SaveArg<0>(&packet2_));
 807     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 808         SaveArg<0>(&packet3_));
 809   }
 810   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
 811                                     MAY_FEC_PROTECT, nullptr);
 812   EXPECT_EQ(data_len, consumed.bytes_consumed);
 813   contents.num_stream_frames = 2u;
 814   CheckPacketContains(contents, packet2_);
 815   CheckPacketIsFec(packet3_, /*fec_group=*/1u);
 816
 817   // FEC protection should be off in creator.
 818   EXPECT_FALSE(creator_->IsFecProtected());
 819 }
 820
 821 TEST_F(QuicPacketGeneratorTest, SwitchFecOnOffThenOnWithCreatorProtectionOn) {
 822   delegate_.SetCanWriteAnything();
 823   generator_.StartBatchOperations();
 824
 825   // Enable FEC.
 826   creator_->set_max_packets_per_fec_group(2);
 827   EXPECT_FALSE(creator_->IsFecProtected());
 828
 829   // Queue one byte of FEC protected data.
 830   QuicConsumedData consumed = generator_.ConsumeData(5, CreateData(1u), 0, true,
 831                                                      MUST_FEC_PROTECT, nullptr);
 832   EXPECT_TRUE(creator_->HasPendingFrames());
 833
 834   // Add more unprotected data causing first packet to be sent, FEC protected.
 835   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 836       SaveArg<0>(&packet_));
 837   size_t data_len = kDefaultMaxPacketSize;
 838   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
 839                                     MAY_FEC_PROTECT, nullptr);
 840   EXPECT_EQ(data_len, consumed.bytes_consumed);
 841   PacketContents contents;
 842   contents.num_stream_frames = 2u;
 843   contents.fec_group = 1u;
 844   CheckPacketContains(contents, packet_);
 845
 846   // FEC group is still open in creator.
 847   EXPECT_TRUE(creator_->IsFecProtected());
 848
 849   // Add data that should be protected, large enough to cause second packet to
 850   // be sent. Data packet should be followed by FEC packet.
 851   {
 852     InSequence dummy;
 853     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 854         SaveArg<0>(&packet2_));
 855     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 856         SaveArg<0>(&packet3_));
 857   }
 858   consumed = generator_.ConsumeData(5, CreateData(data_len), 0, true,
 859                                     MUST_FEC_PROTECT, nullptr);
 860   EXPECT_EQ(data_len, consumed.bytes_consumed);
 861   CheckPacketContains(contents, packet2_);
 862   CheckPacketIsFec(packet3_, /*fec_group=*/1u);
 863
 864   // FEC protection should remain on in creator.
 865   EXPECT_TRUE(creator_->IsFecProtected());
 866 }
 867
 868 TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations) {
 869   delegate_.SetCanNotWrite();
 870
 871   generator_.SetShouldSendAck(true, false);
 872   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 873   EXPECT_TRUE(generator_.HasQueuedFrames());
 874
 875   delegate_.SetCanWriteAnything();
 876
 877   generator_.StartBatchOperations();
 878
 879   // When the first write operation is invoked, the ack and feedback
 880   // frames will be returned.
 881   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 882   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
 883       Return(CreateFeedbackFrame()));
 884
 885   // Send some data and a control frame
 886   generator_.ConsumeData(3, MakeIOVector("quux"), 7, false, MAY_FEC_PROTECT,
 887                          nullptr);
 888   generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame()));
 889
 890   // All five frames will be flushed out in a single packet.
 891   EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(SaveArg<0>(&packet_));
 892   generator_.FinishBatchOperations();
 893   EXPECT_FALSE(generator_.HasQueuedFrames());
 894
 895   PacketContents contents;
 896   contents.num_ack_frames = 1;
 897   contents.num_goaway_frames = 1;
 898   contents.num_feedback_frames = 1;
 899   contents.num_rst_stream_frames = 1;
 900   contents.num_stream_frames = 1;
 901   CheckPacketContains(contents, packet_);
 902 }
 903
 904 TEST_F(QuicPacketGeneratorTest, NotWritableThenBatchOperations2) {
 905   delegate_.SetCanNotWrite();
 906
 907   generator_.SetShouldSendAck(true, false);
 908   generator_.AddControlFrame(QuicFrame(CreateRstStreamFrame()));
 909   EXPECT_TRUE(generator_.HasQueuedFrames());
 910
 911   delegate_.SetCanWriteAnything();
 912
 913   generator_.StartBatchOperations();
 914
 915   // When the first write operation is invoked, the ack and feedback
 916   // frames will be returned.
 917   EXPECT_CALL(delegate_, CreateAckFrame()).WillOnce(Return(CreateAckFrame()));
 918   EXPECT_CALL(delegate_, CreateFeedbackFrame()).WillOnce(
 919       Return(CreateFeedbackFrame()));
 920
 921   {
 922     InSequence dummy;
 923     // All five frames will be flushed out in a single packet
 924     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 925         SaveArg<0>(&packet_));
 926     EXPECT_CALL(delegate_, OnSerializedPacket(_)).WillOnce(
 927         SaveArg<0>(&packet2_));
 928   }
 929
 930   // Send enough data to exceed one packet
 931   size_t data_len = kDefaultMaxPacketSize + 100;
 932   QuicConsumedData consumed = generator_.ConsumeData(
 933       3, CreateData(data_len), 0, true, MAY_FEC_PROTECT, nullptr);
 934   EXPECT_EQ(data_len, consumed.bytes_consumed);
 935   EXPECT_TRUE(consumed.fin_consumed);
 936   generator_.AddControlFrame(QuicFrame(CreateGoAwayFrame()));
 937
 938   generator_.FinishBatchOperations();
 939   EXPECT_FALSE(generator_.HasQueuedFrames());
 940
 941   // The first packet should have the queued data and part of the stream data.
 942   PacketContents contents;
 943   contents.num_ack_frames = 1;
 944   contents.num_feedback_frames = 1;
 945   contents.num_rst_stream_frames = 1;
 946   contents.num_stream_frames = 1;
 947   CheckPacketContains(contents, packet_);
 948
 949   // The second should have the remainder of the stream data.
 950   PacketContents contents2;
 951   contents2.num_goaway_frames = 1;
 952   contents2.num_stream_frames = 1;
 953   CheckPacketContains(contents2, packet2_);
 954 }
 955
 956 TEST_F(QuicPacketGeneratorTest, TestConnectionIdLength) {
 957   generator_.SetConnectionIdLength(0);
 958   EXPECT_EQ(PACKET_0BYTE_CONNECTION_ID, creator_->connection_id_length());
 959   generator_.SetConnectionIdLength(1);
 960   EXPECT_EQ(PACKET_1BYTE_CONNECTION_ID, creator_->connection_id_length());
 961   generator_.SetConnectionIdLength(2);
 962   EXPECT_EQ(PACKET_4BYTE_CONNECTION_ID, creator_->connection_id_length());
 963   generator_.SetConnectionIdLength(3);
 964   EXPECT_EQ(PACKET_4BYTE_CONNECTION_ID, creator_->connection_id_length());
 965   generator_.SetConnectionIdLength(4);
 966   EXPECT_EQ(PACKET_4BYTE_CONNECTION_ID, creator_->connection_id_length());
 967   generator_.SetConnectionIdLength(5);
 968   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
 969   generator_.SetConnectionIdLength(6);
 970   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
 971   generator_.SetConnectionIdLength(7);
 972   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
 973   generator_.SetConnectionIdLength(8);
 974   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
 975   generator_.SetConnectionIdLength(9);
 976   EXPECT_EQ(PACKET_8BYTE_CONNECTION_ID, creator_->connection_id_length());
 977 }
 978
 979 }  // namespace test
 980 }  // namespace net