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/crypto/quic_random.h"
  12 #include "net/quic/quic_utils.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:
  32   QuicPacketCreatorTest()
  33       : server_framer_(kQuicVersion1,
  34                        QuicDecrypter::Create(kNULL),
  35                        QuicEncrypter::Create(kNULL),
  36                        QuicTime::Zero(),
  37                        true),
  38         client_framer_(kQuicVersion1,
  39                        QuicDecrypter::Create(kNULL),
  40                        QuicEncrypter::Create(kNULL),
  41                        QuicTime::Zero(),
  42                        false),
  43         id_(1),
  44         sequence_number_(0),
  45         guid_(2),
  46         data_("foo"),
  47         creator_(guid_, &client_framer_, QuicRandom::GetInstance(), false) {
  48     client_framer_.set_visitor(&framer_visitor_);
  49     server_framer_.set_visitor(&framer_visitor_);
  50   }
  51   ~QuicPacketCreatorTest() {
  52   }
  53
  54   void ProcessPacket(QuicPacket* packet) {
  55     scoped_ptr<QuicEncryptedPacket> encrypted(
  56         server_framer_.EncryptPacket(sequence_number_, *packet));
  57     server_framer_.ProcessPacket(*encrypted);
  58   }
  59
  60   void CheckStreamFrame(const QuicFrame& frame, QuicStreamId stream_id,
  61                         const string& data, QuicStreamOffset offset, bool fin) {
  62     EXPECT_EQ(STREAM_FRAME, frame.type);
  63     ASSERT_TRUE(frame.stream_frame);
  64     EXPECT_EQ(stream_id, frame.stream_frame->stream_id);
  65     EXPECT_EQ(data, frame.stream_frame->data);
  66     EXPECT_EQ(offset, frame.stream_frame->offset);
  67     EXPECT_EQ(fin, frame.stream_frame->fin);
  68   }
  69
  70   QuicFrames frames_;
  71   QuicFramer server_framer_;
  72   QuicFramer client_framer_;
  73   testing::StrictMock<MockFramerVisitor> framer_visitor_;
  74   QuicStreamId id_;
  75   QuicPacketSequenceNumber sequence_number_;
  76   QuicGuid guid_;
  77   string data_;
  78   QuicPacketCreator creator_;
  79 };
  80
  81 TEST_F(QuicPacketCreatorTest, SerializeFrames) {
  82   frames_.push_back(QuicFrame(new QuicAckFrame(0u, QuicTime::Zero(), 0u)));
  83   frames_.push_back(QuicFrame(new QuicStreamFrame(
  84       0u, false, 0u, StringPiece(""))));
  85   frames_.push_back(QuicFrame(new QuicStreamFrame(
  86       0u, true, 0u, StringPiece(""))));
  87   SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
  88   delete frames_[0].ack_frame;
  89   delete frames_[1].stream_frame;
  90   delete frames_[2].stream_frame;
  91
  92   {
  93     InSequence s;
  94     EXPECT_CALL(framer_visitor_, OnPacket());
  95     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
  96     EXPECT_CALL(framer_visitor_, OnAckFrame(_));
  97     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
  98     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
  99     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 100   }
 101   ProcessPacket(serialized.packet);
 102   delete serialized.packet;
 103 }
 104
 105 TEST_F(QuicPacketCreatorTest, SerializeWithFEC) {
 106   creator_.options()->max_packets_per_fec_group = 6;
 107   ASSERT_FALSE(creator_.ShouldSendFec(false));
 108   creator_.MaybeStartFEC();
 109
 110   frames_.push_back(QuicFrame(new QuicStreamFrame(
 111       0u, false, 0u, StringPiece(""))));
 112   SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
 113   delete frames_[0].stream_frame;
 114
 115   {
 116     InSequence s;
 117     EXPECT_CALL(framer_visitor_, OnPacket());
 118     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 119     EXPECT_CALL(framer_visitor_, OnFecProtectedPayload(_));
 120     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
 121     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 122   }
 123   ProcessPacket(serialized.packet);
 124   delete serialized.packet;
 125
 126   ASSERT_FALSE(creator_.ShouldSendFec(false));
 127   ASSERT_TRUE(creator_.ShouldSendFec(true));
 128
 129   serialized = creator_.SerializeFec();
 130   ASSERT_EQ(2u, serialized.sequence_number);
 131
 132   {
 133     InSequence s;
 134     EXPECT_CALL(framer_visitor_, OnPacket());
 135     EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 136     EXPECT_CALL(framer_visitor_, OnFecData(_));
 137     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 138   }
 139   ProcessPacket(serialized.packet);
 140   delete serialized.packet;
 141 }
 142
 143 TEST_F(QuicPacketCreatorTest, SerializeConnectionClose) {
 144   QuicConnectionCloseFrame frame;
 145   frame.error_code = QUIC_NO_ERROR;
 146   frame.ack_frame = QuicAckFrame(0u, QuicTime::Zero(), 0u);
 147
 148   SerializedPacket serialized = creator_.SerializeConnectionClose(&frame);
 149   ASSERT_EQ(1u, serialized.sequence_number);
 150   ASSERT_EQ(1u, creator_.sequence_number());
 151
 152   InSequence s;
 153   EXPECT_CALL(framer_visitor_, OnPacket());
 154   EXPECT_CALL(framer_visitor_, OnPacketHeader(_));
 155   EXPECT_CALL(framer_visitor_, OnAckFrame(_));
 156   EXPECT_CALL(framer_visitor_, OnConnectionCloseFrame(_));
 157   EXPECT_CALL(framer_visitor_, OnPacketComplete());
 158
 159   ProcessPacket(serialized.packet);
 160   delete serialized.packet;
 161 }
 162
 163 TEST_F(QuicPacketCreatorTest, CreateStreamFrame) {
 164   QuicFrame frame;
 165   size_t consumed = creator_.CreateStreamFrame(1u, "test", 0u, false, &frame);
 166   EXPECT_EQ(4u, consumed);
 167   CheckStreamFrame(frame, 1u, "test", 0u, false);
 168   delete frame.stream_frame;
 169 }
 170
 171 TEST_F(QuicPacketCreatorTest, CreateStreamFrameFin) {
 172   QuicFrame frame;
 173   size_t consumed = creator_.CreateStreamFrame(1u, "test", 10u, true, &frame);
 174   EXPECT_EQ(4u, consumed);
 175   CheckStreamFrame(frame, 1u, "test", 10u, true);
 176   delete frame.stream_frame;
 177 }
 178
 179 TEST_F(QuicPacketCreatorTest, CreateStreamFrameFinOnly) {
 180   QuicFrame frame;
 181   size_t consumed = creator_.CreateStreamFrame(1u, "", 0u, true, &frame);
 182   EXPECT_EQ(0u, consumed);
 183   CheckStreamFrame(frame, 1u, std::string(), 0u, true);
 184   delete frame.stream_frame;
 185 }
 186
 187 TEST_F(QuicPacketCreatorTest, SerializeVersionNegotiationPacket) {
 188   QuicPacketCreatorPeer::SetIsServer(&creator_, true);
 189   QuicVersionTagList versions;
 190   versions.push_back(kQuicVersion1);
 191   scoped_ptr<QuicEncryptedPacket> encrypted(
 192       creator_.SerializeVersionNegotiationPacket(versions));
 193
 194   {
 195     InSequence s;
 196     EXPECT_CALL(framer_visitor_, OnPacket());
 197     EXPECT_CALL(framer_visitor_, OnVersionNegotiationPacket(_));
 198   }
 199   client_framer_.ProcessPacket(*encrypted.get());
 200 }
 201
 202 INSTANTIATE_TEST_CASE_P(ToggleVersionSerialization,
 203                         QuicPacketCreatorTest,
 204                         ::testing::Values(false, true));
 205
 206 TEST_P(QuicPacketCreatorTest, SerializeFrame) {
 207   if (!GetParam()) {
 208     creator_.StopSendingVersion();
 209   }
 210   frames_.push_back(QuicFrame(new QuicStreamFrame(
 211       0u, false, 0u, StringPiece(""))));
 212   SerializedPacket serialized = creator_.SerializeAllFrames(frames_);
 213   delete frames_[0].stream_frame;
 214
 215   QuicPacketHeader header;
 216   {
 217     InSequence s;
 218     EXPECT_CALL(framer_visitor_, OnPacket());
 219     EXPECT_CALL(framer_visitor_, OnPacketHeader(_)).WillOnce(
 220         DoAll(SaveArg<0>(&header), Return(true)));
 221     EXPECT_CALL(framer_visitor_, OnStreamFrame(_));
 222     EXPECT_CALL(framer_visitor_, OnPacketComplete());
 223   }
 224   ProcessPacket(serialized.packet);
 225   EXPECT_EQ(GetParam(), header.public_header.version_flag);
 226   delete serialized.packet;
 227 }
 228
 229 TEST_P(QuicPacketCreatorTest, CreateStreamFrameTooLarge) {
 230   if (!GetParam()) {
 231     creator_.StopSendingVersion();
 232   }
 233   // A string larger than fits into a frame.
 234   creator_.options()->max_packet_length = GetPacketLengthForOneStream(
 235       QuicPacketCreatorPeer::SendVersionInPacket(&creator_), 4);
 236   QuicFrame frame;
 237   size_t consumed = creator_.CreateStreamFrame(1u, "testTooLong", 0u, true,
 238                                                &frame);
 239   EXPECT_EQ(4u, consumed);
 240   CheckStreamFrame(frame, 1u, "test", 0u, false);
 241   delete frame.stream_frame;
 242 }
 243
 244 TEST_P(QuicPacketCreatorTest, AddFrameAndSerialize) {
 245   if (!GetParam()) {
 246     creator_.StopSendingVersion();
 247   }
 248   const size_t max_plaintext_size =
 249       client_framer_.GetMaxPlaintextSize(creator_.options()->max_packet_length);
 250   EXPECT_FALSE(creator_.HasPendingFrames());
 251   EXPECT_EQ(max_plaintext_size -
 252             GetPacketHeaderSize(
 253                 QuicPacketCreatorPeer::SendVersionInPacket(&creator_)),
 254             creator_.BytesFree());
 255
 256   // Add a variety of frame types and then a padding frame.
 257   QuicAckFrame ack_frame;
 258   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
 259   EXPECT_TRUE(creator_.HasPendingFrames());
 260
 261   QuicCongestionFeedbackFrame congestion_feedback;
 262   congestion_feedback.type = kFixRate;
 263   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&congestion_feedback)));
 264   EXPECT_TRUE(creator_.HasPendingFrames());
 265
 266   QuicFrame frame;
 267   size_t consumed = creator_.CreateStreamFrame(1u, "test", 0u, false, &frame);
 268   EXPECT_EQ(4u, consumed);
 269   ASSERT_TRUE(frame.stream_frame);
 270   EXPECT_TRUE(creator_.AddSavedFrame(frame));
 271   EXPECT_TRUE(creator_.HasPendingFrames());
 272
 273   QuicPaddingFrame padding_frame;
 274   EXPECT_TRUE(creator_.AddSavedFrame(QuicFrame(&padding_frame)));
 275   EXPECT_TRUE(creator_.HasPendingFrames());
 276   EXPECT_EQ(0u, creator_.BytesFree());
 277
 278   EXPECT_FALSE(creator_.AddSavedFrame(QuicFrame(&ack_frame)));
 279
 280   // Ensure the packet is successfully created.
 281   SerializedPacket serialized = creator_.SerializePacket();
 282   ASSERT_TRUE(serialized.packet);
 283   delete serialized.packet;
 284   ASSERT_TRUE(serialized.retransmittable_frames);
 285   RetransmittableFrames* retransmittable = serialized.retransmittable_frames;
 286   ASSERT_EQ(1u, retransmittable->frames().size());
 287   EXPECT_EQ(STREAM_FRAME, retransmittable->frames()[0].type);
 288   ASSERT_TRUE(retransmittable->frames()[0].stream_frame);
 289   delete serialized.retransmittable_frames;
 290
 291   EXPECT_FALSE(creator_.HasPendingFrames());
 292   EXPECT_EQ(max_plaintext_size -
 293             GetPacketHeaderSize(
 294                 QuicPacketCreatorPeer::SendVersionInPacket(&creator_)),
 295             creator_.BytesFree());
 296 }
 297
 298 }  // namespace
 299 }  // namespace test
 300 }  // namespace net