net/quic/quic_framer_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_framer.h"
   6
   7 #include <stdint.h>
   8 #include <algorithm>
   9 #include <map>
  10 #include <string>
  11 #include <vector>
  12
  13 #include "base/containers/hash_tables.h"
  14 #include "base/logging.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/stl_util.h"
  17 #include "net/quic/crypto/quic_decrypter.h"
  18 #include "net/quic/crypto/quic_encrypter.h"
  19 #include "net/quic/quic_protocol.h"
  20 #include "net/quic/quic_utils.h"
  21 #include "net/quic/test_tools/quic_framer_peer.h"
  22 #include "net/quic/test_tools/quic_test_utils.h"
  23 #include "net/test/gtest_util.h"
  24
  25 using base::hash_set;
  26 using base::StringPiece;
  27 using std::make_pair;
  28 using std::map;
  29 using std::numeric_limits;
  30 using std::pair;
  31 using std::string;
  32 using std::vector;
  33 using testing::Return;
  34 using testing::Truly;
  35 using testing::_;
  36
  37 namespace net {
  38 namespace test {
  39
  40 const QuicPacketNumber kEpoch = UINT64_C(1) << 48;
  41 const QuicPacketNumber kMask = kEpoch - 1;
  42
  43 // Index into the connection_id offset in the header.
  44 const size_t kConnectionIdOffset = kPublicFlagsSize;
  45 // Index into the version string in the header. (if present).
  46 const size_t kVersionOffset = kConnectionIdOffset + PACKET_8BYTE_CONNECTION_ID;
  47
  48 // Size in bytes of the stream frame fields for an arbitrary StreamID and
  49 // offset and the last frame in a packet.
  50 size_t GetMinStreamFrameSize() {
  51   return kQuicFrameTypeSize + kQuicMaxStreamIdSize + kQuicMaxStreamOffsetSize;
  52 }
  53
  54 // Index into the packet number offset in the header.
  55 size_t GetPacketNumberOffset(QuicConnectionIdLength connection_id_length,
  56                              bool include_version) {
  57   return kConnectionIdOffset + connection_id_length +
  58       (include_version ? kQuicVersionSize : 0);
  59 }
  60
  61 size_t GetPacketNumberOffset(bool include_version) {
  62   return GetPacketNumberOffset(PACKET_8BYTE_CONNECTION_ID, include_version);
  63 }
  64
  65 // Index into the private flags offset in the data packet header.
  66 size_t GetPrivateFlagsOffset(QuicConnectionIdLength connection_id_length,
  67                              bool include_version) {
  68   return GetPacketNumberOffset(connection_id_length, include_version) +
  69          PACKET_6BYTE_PACKET_NUMBER;
  70 }
  71
  72 size_t GetPrivateFlagsOffset(bool include_version) {
  73   return GetPrivateFlagsOffset(PACKET_8BYTE_CONNECTION_ID, include_version);
  74 }
  75
  76 size_t GetPrivateFlagsOffset(bool include_version,
  77                              QuicPacketNumberLength packet_number_length) {
  78   return GetPacketNumberOffset(PACKET_8BYTE_CONNECTION_ID, include_version) +
  79          packet_number_length;
  80 }
  81
  82 // Index into the fec group offset in the header.
  83 size_t GetFecGroupOffset(QuicConnectionIdLength connection_id_length,
  84                          bool include_version) {
  85   return GetPrivateFlagsOffset(connection_id_length, include_version) +
  86       kPrivateFlagsSize;
  87 }
  88
  89 size_t GetFecGroupOffset(bool include_version) {
  90   return GetPrivateFlagsOffset(PACKET_8BYTE_CONNECTION_ID, include_version) +
  91       kPrivateFlagsSize;
  92 }
  93
  94 size_t GetFecGroupOffset(bool include_version,
  95                          QuicPacketNumberLength packet_number_length) {
  96   return GetPrivateFlagsOffset(include_version, packet_number_length) +
  97          kPrivateFlagsSize;
  98 }
  99
 100 // Index into the message tag of the public reset packet.
 101 // Public resets always have full connection_ids.
 102 const size_t kPublicResetPacketMessageTagOffset =
 103     kConnectionIdOffset + PACKET_8BYTE_CONNECTION_ID;
 104
 105 class TestEncrypter : public QuicEncrypter {
 106  public:
 107   ~TestEncrypter() override {}
 108   bool SetKey(StringPiece key) override { return true; }
 109   bool SetNoncePrefix(StringPiece nonce_prefix) override { return true; }
 110   bool EncryptPacket(QuicPacketNumber packet_number,
 111                      StringPiece associated_data,
 112                      StringPiece plaintext,
 113                      char* output,
 114                      size_t* output_length,
 115                      size_t max_output_length) override {
 116     packet_number_ = packet_number;
 117     associated_data_ = associated_data.as_string();
 118     plaintext_ = plaintext.as_string();
 119     memcpy(output, plaintext.data(), plaintext.length());
 120     *output_length = plaintext.length();
 121     return true;
 122   }
 123   size_t GetKeySize() const override { return 0; }
 124   size_t GetNoncePrefixSize() const override { return 0; }
 125   size_t GetMaxPlaintextSize(size_t ciphertext_size) const override {
 126     return ciphertext_size;
 127   }
 128   size_t GetCiphertextSize(size_t plaintext_size) const override {
 129     return plaintext_size;
 130   }
 131   StringPiece GetKey() const override { return StringPiece(); }
 132   StringPiece GetNoncePrefix() const override { return StringPiece(); }
 133   QuicPacketNumber packet_number_;
 134   string associated_data_;
 135   string plaintext_;
 136 };
 137
 138 class TestDecrypter : public QuicDecrypter {
 139  public:
 140   ~TestDecrypter() override {}
 141   bool SetKey(StringPiece key) override { return true; }
 142   bool SetNoncePrefix(StringPiece nonce_prefix) override { return true; }
 143   bool DecryptPacket(QuicPacketNumber packet_number,
 144                      const StringPiece& associated_data,
 145                      const StringPiece& ciphertext,
 146                      char* output,
 147                      size_t* output_length,
 148                      size_t max_output_length) override {
 149     packet_number_ = packet_number;
 150     associated_data_ = associated_data.as_string();
 151     ciphertext_ = ciphertext.as_string();
 152     memcpy(output, ciphertext.data(), ciphertext.length());
 153     *output_length = ciphertext.length();
 154     return true;
 155   }
 156   StringPiece GetKey() const override { return StringPiece(); }
 157   StringPiece GetNoncePrefix() const override { return StringPiece(); }
 158   const char* cipher_name() const override { return "Test"; }
 159   // Use a distinct value starting with 0xFFFFFF, which is never used by TLS.
 160   uint32 cipher_id() const override { return 0xFFFFFFF2; }
 161   QuicPacketNumber packet_number_;
 162   string associated_data_;
 163   string ciphertext_;
 164 };
 165
 166 class TestQuicVisitor : public QuicFramerVisitorInterface {
 167  public:
 168   TestQuicVisitor()
 169       : error_count_(0),
 170         version_mismatch_(0),
 171         packet_count_(0),
 172         frame_count_(0),
 173         fec_count_(0),
 174         complete_packets_(0),
 175         revived_packets_(0),
 176         accept_packet_(true),
 177         accept_public_header_(true) {
 178   }
 179
 180   ~TestQuicVisitor() override {
 181     STLDeleteElements(&stream_frames_);
 182     STLDeleteElements(&ack_frames_);
 183     STLDeleteElements(&stop_waiting_frames_);
 184     STLDeleteElements(&ping_frames_);
 185     STLDeleteElements(&fec_data_);
 186     STLDeleteElements(&stream_data_);
 187     STLDeleteElements(&fec_data_redundancy_);
 188   }
 189
 190   void OnError(QuicFramer* f) override {
 191     DVLOG(1) << "QuicFramer Error: " << QuicUtils::ErrorToString(f->error())
 192              << " (" << f->error() << ")";
 193     ++error_count_;
 194   }
 195
 196   void OnPacket() override {}
 197
 198   void OnPublicResetPacket(const QuicPublicResetPacket& packet) override {
 199     public_reset_packet_.reset(new QuicPublicResetPacket(packet));
 200   }
 201
 202   void OnVersionNegotiationPacket(
 203       const QuicVersionNegotiationPacket& packet) override {
 204     version_negotiation_packet_.reset(new QuicVersionNegotiationPacket(packet));
 205   }
 206
 207   void OnRevivedPacket() override { ++revived_packets_; }
 208
 209   bool OnProtocolVersionMismatch(QuicVersion version) override {
 210     DVLOG(1) << "QuicFramer Version Mismatch, version: " << version;
 211     ++version_mismatch_;
 212     return true;
 213   }
 214
 215   bool OnUnauthenticatedPublicHeader(
 216       const QuicPacketPublicHeader& header) override {
 217     public_header_.reset(new QuicPacketPublicHeader(header));
 218     return accept_public_header_;
 219   }
 220
 221   bool OnUnauthenticatedHeader(const QuicPacketHeader& header) override {
 222     return true;
 223   }
 224
 225   void OnDecryptedPacket(EncryptionLevel level) override {}
 226
 227   bool OnPacketHeader(const QuicPacketHeader& header) override {
 228     ++packet_count_;
 229     header_.reset(new QuicPacketHeader(header));
 230     return accept_packet_;
 231   }
 232
 233   bool OnStreamFrame(const QuicStreamFrame& frame) override {
 234     ++frame_count_;
 235     // Save a copy of the data so it is valid after the packet is processed.
 236     string* string_data = new string();
 237     frame.data.AppendToString(string_data);
 238     stream_data_.push_back(string_data);
 239     QuicStreamFrame* stream_frame = new QuicStreamFrame(frame);
 240     // Make sure that the stream frame points to this data.
 241     stream_frame->data = StringPiece(*string_data);
 242     stream_frames_.push_back(stream_frame);
 243     return true;
 244   }
 245
 246   void OnFecProtectedPayload(StringPiece payload) override {
 247     fec_protected_payload_ = payload.as_string();
 248   }
 249
 250   bool OnAckFrame(const QuicAckFrame& frame) override {
 251     ++frame_count_;
 252     ack_frames_.push_back(new QuicAckFrame(frame));
 253     return true;
 254   }
 255
 256   bool OnStopWaitingFrame(const QuicStopWaitingFrame& frame) override {
 257     ++frame_count_;
 258     stop_waiting_frames_.push_back(new QuicStopWaitingFrame(frame));
 259     return true;
 260   }
 261
 262   bool OnPingFrame(const QuicPingFrame& frame) override {
 263     ++frame_count_;
 264     ping_frames_.push_back(new QuicPingFrame(frame));
 265     return true;
 266   }
 267
 268   void OnFecData(const QuicFecData& fec) override {
 269     ++fec_count_;
 270     QuicFecData* fec_data = new QuicFecData();
 271     fec_data->fec_group = fec.fec_group;
 272     // Save a copy of the data so it is valid after the packet is processed.
 273     string* redundancy = new string(fec.redundancy.as_string());
 274     fec_data_redundancy_.push_back(redundancy);
 275     fec_data->redundancy = StringPiece(*redundancy);
 276     fec_data_.push_back(fec_data);
 277   }
 278
 279   void OnPacketComplete() override { ++complete_packets_; }
 280
 281   bool OnRstStreamFrame(const QuicRstStreamFrame& frame) override {
 282     rst_stream_frame_ = frame;
 283     return true;
 284   }
 285
 286   bool OnConnectionCloseFrame(const QuicConnectionCloseFrame& frame) override {
 287     connection_close_frame_ = frame;
 288     return true;
 289   }
 290
 291   bool OnGoAwayFrame(const QuicGoAwayFrame& frame) override {
 292     goaway_frame_ = frame;
 293     return true;
 294   }
 295
 296   bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& frame) override {
 297     window_update_frame_ = frame;
 298     return true;
 299   }
 300
 301   bool OnBlockedFrame(const QuicBlockedFrame& frame) override {
 302     blocked_frame_ = frame;
 303     return true;
 304   }
 305
 306   // Counters from the visitor_ callbacks.
 307   int error_count_;
 308   int version_mismatch_;
 309   int packet_count_;
 310   int frame_count_;
 311   int fec_count_;
 312   int complete_packets_;
 313   int revived_packets_;
 314   bool accept_packet_;
 315   bool accept_public_header_;
 316
 317   scoped_ptr<QuicPacketHeader> header_;
 318   scoped_ptr<QuicPacketPublicHeader> public_header_;
 319   scoped_ptr<QuicPublicResetPacket> public_reset_packet_;
 320   scoped_ptr<QuicVersionNegotiationPacket> version_negotiation_packet_;
 321   vector<QuicStreamFrame*> stream_frames_;
 322   vector<QuicAckFrame*> ack_frames_;
 323   vector<QuicStopWaitingFrame*> stop_waiting_frames_;
 324   vector<QuicPingFrame*> ping_frames_;
 325   vector<QuicFecData*> fec_data_;
 326   string fec_protected_payload_;
 327   QuicRstStreamFrame rst_stream_frame_;
 328   QuicConnectionCloseFrame connection_close_frame_;
 329   QuicGoAwayFrame goaway_frame_;
 330   QuicWindowUpdateFrame window_update_frame_;
 331   QuicBlockedFrame blocked_frame_;
 332   vector<string*> stream_data_;
 333   vector<string*> fec_data_redundancy_;
 334 };
 335
 336 class QuicFramerTest : public ::testing::TestWithParam<QuicVersion> {
 337  public:
 338   QuicFramerTest()
 339       : encrypter_(new test::TestEncrypter()),
 340         decrypter_(new test::TestDecrypter()),
 341         start_(QuicTime::Zero().Add(QuicTime::Delta::FromMicroseconds(0x10))),
 342         framer_(QuicSupportedVersions(), start_, Perspective::IS_SERVER) {
 343     version_ = GetParam();
 344     framer_.set_version(version_);
 345     framer_.SetDecrypter(ENCRYPTION_NONE, decrypter_);
 346     framer_.SetEncrypter(ENCRYPTION_NONE, encrypter_);
 347     framer_.set_visitor(&visitor_);
 348     framer_.set_received_entropy_calculator(&entropy_calculator_);
 349   }
 350
 351   // Helper function to get unsigned char representation of digit in the
 352   // units place of the current QUIC version number.
 353   unsigned char GetQuicVersionDigitOnes() {
 354     return static_cast<unsigned char> ('0' + version_%10);
 355   }
 356
 357   // Helper function to get unsigned char representation of digit in the
 358   // tens place of the current QUIC version number.
 359   unsigned char GetQuicVersionDigitTens() {
 360     return static_cast<unsigned char> ('0' + (version_/10)%10);
 361   }
 362
 363   bool CheckEncryption(QuicPacketNumber packet_number, QuicPacket* packet) {
 364     if (packet_number != encrypter_->packet_number_) {
 365       LOG(ERROR) << "Encrypted incorrect packet number.  expected "
 366                  << packet_number << " actual: " << encrypter_->packet_number_;
 367       return false;
 368     }
 369     if (packet->AssociatedData() != encrypter_->associated_data_) {
 370       LOG(ERROR) << "Encrypted incorrect associated data.  expected "
 371                  << packet->AssociatedData() << " actual: "
 372                  << encrypter_->associated_data_;
 373       return false;
 374     }
 375     if (packet->Plaintext() != encrypter_->plaintext_) {
 376       LOG(ERROR) << "Encrypted incorrect plaintext data.  expected "
 377                  << packet->Plaintext() << " actual: "
 378                  << encrypter_->plaintext_;
 379       return false;
 380     }
 381     return true;
 382   }
 383
 384   bool CheckDecryption(const QuicEncryptedPacket& encrypted,
 385                        bool includes_version) {
 386     if (visitor_.header_->packet_packet_number != decrypter_->packet_number_) {
 387       LOG(ERROR) << "Decrypted incorrect packet number.  expected "
 388                  << visitor_.header_->packet_packet_number
 389                  << " actual: " << decrypter_->packet_number_;
 390       return false;
 391     }
 392     if (QuicFramer::GetAssociatedDataFromEncryptedPacket(
 393             encrypted, PACKET_8BYTE_CONNECTION_ID, includes_version,
 394             PACKET_6BYTE_PACKET_NUMBER) != decrypter_->associated_data_) {
 395       LOG(ERROR) << "Decrypted incorrect associated data.  expected "
 396                  << QuicFramer::GetAssociatedDataFromEncryptedPacket(
 397                         encrypted, PACKET_8BYTE_CONNECTION_ID, includes_version,
 398                         PACKET_6BYTE_PACKET_NUMBER)
 399                  << " actual: " << decrypter_->associated_data_;
 400       return false;
 401     }
 402     StringPiece ciphertext(encrypted.AsStringPiece().substr(
 403         GetStartOfEncryptedData(PACKET_8BYTE_CONNECTION_ID, includes_version,
 404                                 PACKET_6BYTE_PACKET_NUMBER)));
 405     if (ciphertext != decrypter_->ciphertext_) {
 406       LOG(ERROR) << "Decrypted incorrect ciphertext data.  expected "
 407                  << ciphertext << " actual: "
 408                  << decrypter_->ciphertext_;
 409       return false;
 410     }
 411     return true;
 412   }
 413
 414   char* AsChars(unsigned char* data) {
 415     return reinterpret_cast<char*>(data);
 416   }
 417
 418   void CheckProcessingFails(unsigned char* packet,
 419                             size_t len,
 420                             string expected_error,
 421                             QuicErrorCode error_code) {
 422     QuicEncryptedPacket encrypted(AsChars(packet), len, false);
 423     EXPECT_FALSE(framer_.ProcessPacket(encrypted)) << "len: " << len;
 424     EXPECT_EQ(expected_error, framer_.detailed_error()) << "len: " << len;
 425     EXPECT_EQ(error_code, framer_.error()) << "len: " << len;
 426   }
 427
 428   // Checks if the supplied string matches data in the supplied StreamFrame.
 429   void CheckStreamFrameData(string str, QuicStreamFrame* frame) {
 430     EXPECT_EQ(str, frame->data);
 431   }
 432
 433   void CheckStreamFrameBoundaries(unsigned char* packet,
 434                                   size_t stream_id_size,
 435                                   bool include_version) {
 436     // Now test framing boundaries.
 437     for (size_t i = kQuicFrameTypeSize; i < GetMinStreamFrameSize(); ++i) {
 438       string expected_error;
 439       if (i < kQuicFrameTypeSize + stream_id_size) {
 440         expected_error = "Unable to read stream_id.";
 441       } else if (i < kQuicFrameTypeSize + stream_id_size +
 442                          kQuicMaxStreamOffsetSize) {
 443         expected_error = "Unable to read offset.";
 444       } else {
 445         expected_error = "Unable to read frame data.";
 446       }
 447       CheckProcessingFails(
 448           packet,
 449           i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, include_version,
 450                                   PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
 451           expected_error, QUIC_INVALID_STREAM_DATA);
 452     }
 453   }
 454
 455   void CheckCalculatePacketNumber(QuicPacketNumber expected_packet_number,
 456                                   QuicPacketNumber last_packet_number) {
 457     QuicPacketNumber wire_packet_number = expected_packet_number & kMask;
 458     QuicFramerPeer::SetLastPacketNumber(&framer_, last_packet_number);
 459     EXPECT_EQ(expected_packet_number,
 460               QuicFramerPeer::CalculatePacketNumberFromWire(
 461                   &framer_, PACKET_6BYTE_PACKET_NUMBER, wire_packet_number))
 462         << "last_packet_number: " << last_packet_number
 463         << " wire_packet_number: " << wire_packet_number;
 464   }
 465
 466   QuicPacket* BuildDataPacket(const QuicPacketHeader& header,
 467                               const QuicFrames& frames) {
 468     return BuildUnsizedDataPacket(&framer_, header, frames);
 469   }
 470
 471   QuicPacket* BuildDataPacket(const QuicPacketHeader& header,
 472                               const QuicFrames& frames,
 473                               size_t packet_size) {
 474     return BuildUnsizedDataPacket(&framer_, header, frames, packet_size);
 475   }
 476
 477   test::TestEncrypter* encrypter_;
 478   test::TestDecrypter* decrypter_;
 479   QuicVersion version_;
 480   QuicTime start_;
 481   QuicFramer framer_;
 482   test::TestQuicVisitor visitor_;
 483   test::TestEntropyCalculator entropy_calculator_;
 484 };
 485
 486 // Run all framer tests with all supported versions of QUIC.
 487 INSTANTIATE_TEST_CASE_P(QuicFramerTests,
 488                         QuicFramerTest,
 489                         ::testing::ValuesIn(kSupportedQuicVersions));
 490
 491 TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearEpochStart) {
 492   // A few quick manual sanity checks.
 493   CheckCalculatePacketNumber(UINT64_C(1), UINT64_C(0));
 494   CheckCalculatePacketNumber(kEpoch + 1, kMask);
 495   CheckCalculatePacketNumber(kEpoch, kMask);
 496
 497   // Cases where the last number was close to the start of the range.
 498   for (uint64 last = 0; last < 10; last++) {
 499     // Small numbers should not wrap (even if they're out of order).
 500     for (uint64 j = 0; j < 10; j++) {
 501       CheckCalculatePacketNumber(j, last);
 502     }
 503
 504     // Large numbers should not wrap either (because we're near 0 already).
 505     for (uint64 j = 0; j < 10; j++) {
 506       CheckCalculatePacketNumber(kEpoch - 1 - j, last);
 507     }
 508   }
 509 }
 510
 511 TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearEpochEnd) {
 512   // Cases where the last number was close to the end of the range
 513   for (uint64 i = 0; i < 10; i++) {
 514     QuicPacketNumber last = kEpoch - i;
 515
 516     // Small numbers should wrap.
 517     for (uint64 j = 0; j < 10; j++) {
 518       CheckCalculatePacketNumber(kEpoch + j, last);
 519     }
 520
 521     // Large numbers should not (even if they're out of order).
 522     for (uint64 j = 0; j < 10; j++) {
 523       CheckCalculatePacketNumber(kEpoch - 1 - j, last);
 524     }
 525   }
 526 }
 527
 528 // Next check where we're in a non-zero epoch to verify we handle
 529 // reverse wrapping, too.
 530 TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearPrevEpoch) {
 531   const uint64 prev_epoch = 1 * kEpoch;
 532   const uint64 cur_epoch = 2 * kEpoch;
 533   // Cases where the last number was close to the start of the range
 534   for (uint64 i = 0; i < 10; i++) {
 535     uint64 last = cur_epoch + i;
 536     // Small number should not wrap (even if they're out of order).
 537     for (uint64 j = 0; j < 10; j++) {
 538       CheckCalculatePacketNumber(cur_epoch + j, last);
 539     }
 540
 541     // But large numbers should reverse wrap.
 542     for (uint64 j = 0; j < 10; j++) {
 543       uint64 num = kEpoch - 1 - j;
 544       CheckCalculatePacketNumber(prev_epoch + num, last);
 545     }
 546   }
 547 }
 548
 549 TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearNextEpoch) {
 550   const uint64 cur_epoch = 2 * kEpoch;
 551   const uint64 next_epoch = 3 * kEpoch;
 552   // Cases where the last number was close to the end of the range
 553   for (uint64 i = 0; i < 10; i++) {
 554     QuicPacketNumber last = next_epoch - 1 - i;
 555
 556     // Small numbers should wrap.
 557     for (uint64 j = 0; j < 10; j++) {
 558       CheckCalculatePacketNumber(next_epoch + j, last);
 559     }
 560
 561     // but large numbers should not (even if they're out of order).
 562     for (uint64 j = 0; j < 10; j++) {
 563       uint64 num = kEpoch - 1 - j;
 564       CheckCalculatePacketNumber(cur_epoch + num, last);
 565     }
 566   }
 567 }
 568
 569 TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearNextMax) {
 570   const uint64 max_number = numeric_limits<uint64>::max();
 571   const uint64 max_epoch = max_number & ~kMask;
 572
 573   // Cases where the last number was close to the end of the range
 574   for (uint64 i = 0; i < 10; i++) {
 575     // Subtract 1, because the expected next packet number is 1 more than the
 576     // last packet number.
 577     QuicPacketNumber last = max_number - i - 1;
 578
 579     // Small numbers should not wrap, because they have nowhere to go.
 580     for (uint64 j = 0; j < 10; j++) {
 581       CheckCalculatePacketNumber(max_epoch + j, last);
 582     }
 583
 584     // Large numbers should not wrap either.
 585     for (uint64 j = 0; j < 10; j++) {
 586       uint64 num = kEpoch - 1 - j;
 587       CheckCalculatePacketNumber(max_epoch + num, last);
 588     }
 589   }
 590 }
 591
 592 TEST_P(QuicFramerTest, EmptyPacket) {
 593   char packet[] = { 0x00 };
 594   QuicEncryptedPacket encrypted(packet, 0, false);
 595   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 596   EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
 597 }
 598
 599 TEST_P(QuicFramerTest, LargePacket) {
 600   // clang-format off
 601   unsigned char packet[kMaxPacketSize + 1] = {
 602     // public flags (8 byte connection_id)
 603     0x3C,
 604     // connection_id
 605     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
 606     // packet number
 607     0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
 608     // private flags
 609     0x00,
 610   };
 611
 612   memset(packet + GetPacketHeaderSize(
 613              PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
 614              PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP), 0,
 615          kMaxPacketSize - GetPacketHeaderSize(
 616              PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
 617              PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP) + 1);
 618   // clang-format on
 619
 620   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
 621   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 622
 623   ASSERT_TRUE(visitor_.header_.get());
 624   // Make sure we've parsed the packet header, so we can send an error.
 625   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
 626             visitor_.header_->public_header.connection_id);
 627   // Make sure the correct error is propagated.
 628   EXPECT_EQ(QUIC_PACKET_TOO_LARGE, framer_.error());
 629 }
 630
 631 TEST_P(QuicFramerTest, PacketHeader) {
 632   // clang-format off
 633   unsigned char packet[] = {
 634     // public flags (8 byte connection_id)
 635     0x3C,
 636     // connection_id
 637     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
 638     // packet number
 639     0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
 640     // private flags
 641     0x00,
 642   };
 643   // clang-format on
 644
 645   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
 646   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 647   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
 648   ASSERT_TRUE(visitor_.header_.get());
 649   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
 650             visitor_.header_->public_header.connection_id);
 651   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
 652   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
 653   EXPECT_FALSE(visitor_.header_->fec_flag);
 654   EXPECT_FALSE(visitor_.header_->entropy_flag);
 655   EXPECT_EQ(0, visitor_.header_->entropy_hash);
 656   EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_packet_number);
 657   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
 658   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
 659
 660   // Now test framing boundaries.
 661   for (size_t i = 0;
 662        i < GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
 663                                PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
 664        ++i) {
 665     string expected_error;
 666     if (i < kConnectionIdOffset) {
 667       expected_error = "Unable to read public flags.";
 668     } else if (i < GetPacketNumberOffset(!kIncludeVersion)) {
 669       expected_error = "Unable to read ConnectionId.";
 670     } else if (i < GetPrivateFlagsOffset(!kIncludeVersion)) {
 671       expected_error = "Unable to read packet number.";
 672     } else if (i < GetFecGroupOffset(!kIncludeVersion)) {
 673       expected_error = "Unable to read private flags.";
 674     } else {
 675       expected_error = "Unable to read first fec protected packet offset.";
 676     }
 677     CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
 678   }
 679 }
 680
 681 TEST_P(QuicFramerTest, PacketHeaderWith4ByteConnectionId) {
 682   QuicFramerPeer::SetLastSerializedConnectionId(
 683       &framer_, UINT64_C(0xFEDCBA9876543210));
 684
 685   // clang-format off
 686   unsigned char packet[] = {
 687     // public flags (4 byte connection_id)
 688     0x38,
 689     // connection_id
 690     0x10, 0x32, 0x54, 0x76,
 691     // packet number
 692     0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
 693     // private flags
 694     0x00,
 695   };
 696   // clang-format on
 697
 698   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
 699   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 700   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
 701   ASSERT_TRUE(visitor_.header_.get());
 702   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
 703             visitor_.header_->public_header.connection_id);
 704   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
 705   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
 706   EXPECT_FALSE(visitor_.header_->fec_flag);
 707   EXPECT_FALSE(visitor_.header_->entropy_flag);
 708   EXPECT_EQ(0, visitor_.header_->entropy_hash);
 709   EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_packet_number);
 710   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
 711   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
 712
 713   // Now test framing boundaries.
 714   for (size_t i = 0;
 715        i < GetPacketHeaderSize(PACKET_4BYTE_CONNECTION_ID, !kIncludeVersion,
 716                                PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
 717        ++i) {
 718     string expected_error;
 719     if (i < kConnectionIdOffset) {
 720       expected_error = "Unable to read public flags.";
 721     } else if (i < GetPacketNumberOffset(PACKET_4BYTE_CONNECTION_ID,
 722                                          !kIncludeVersion)) {
 723       expected_error = "Unable to read ConnectionId.";
 724     } else if (i < GetPrivateFlagsOffset(PACKET_4BYTE_CONNECTION_ID,
 725                                          !kIncludeVersion)) {
 726       expected_error = "Unable to read packet number.";
 727     } else if (i < GetFecGroupOffset(PACKET_4BYTE_CONNECTION_ID,
 728                                      !kIncludeVersion)) {
 729       expected_error = "Unable to read private flags.";
 730     } else {
 731       expected_error = "Unable to read first fec protected packet offset.";
 732     }
 733     CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
 734   }
 735 }
 736
 737 TEST_P(QuicFramerTest, PacketHeader1ByteConnectionId) {
 738   QuicFramerPeer::SetLastSerializedConnectionId(
 739       &framer_, UINT64_C(0xFEDCBA9876543210));
 740
 741   // clang-format off
 742   unsigned char packet[] = {
 743     // public flags (1 byte connection_id)
 744     0x34,
 745     // connection_id
 746     0x10,
 747     // packet number
 748     0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
 749     // private flags
 750     0x00,
 751   };
 752   // clang-format on
 753
 754   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
 755   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 756   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
 757   ASSERT_TRUE(visitor_.header_.get());
 758   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
 759             visitor_.header_->public_header.connection_id);
 760   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
 761   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
 762   EXPECT_FALSE(visitor_.header_->fec_flag);
 763   EXPECT_FALSE(visitor_.header_->entropy_flag);
 764   EXPECT_EQ(0, visitor_.header_->entropy_hash);
 765   EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_packet_number);
 766   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
 767   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
 768
 769   // Now test framing boundaries.
 770   for (size_t i = 0;
 771        i < GetPacketHeaderSize(PACKET_1BYTE_CONNECTION_ID, !kIncludeVersion,
 772                                PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
 773        ++i) {
 774     string expected_error;
 775     if (i < kConnectionIdOffset) {
 776       expected_error = "Unable to read public flags.";
 777     } else if (i < GetPacketNumberOffset(PACKET_1BYTE_CONNECTION_ID,
 778                                          !kIncludeVersion)) {
 779       expected_error = "Unable to read ConnectionId.";
 780     } else if (i < GetPrivateFlagsOffset(PACKET_1BYTE_CONNECTION_ID,
 781                                          !kIncludeVersion)) {
 782       expected_error = "Unable to read packet number.";
 783     } else if (i < GetFecGroupOffset(PACKET_1BYTE_CONNECTION_ID,
 784                                      !kIncludeVersion)) {
 785       expected_error = "Unable to read private flags.";
 786     } else {
 787       expected_error = "Unable to read first fec protected packet offset.";
 788     }
 789     CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
 790   }
 791 }
 792
 793 TEST_P(QuicFramerTest, PacketHeaderWith0ByteConnectionId) {
 794   QuicFramerPeer::SetLastSerializedConnectionId(
 795       &framer_, UINT64_C(0xFEDCBA9876543210));
 796
 797   // clang-format off
 798   unsigned char packet[] = {
 799     // public flags (0 byte connection_id)
 800     0x30,
 801     // connection_id
 802     // packet number
 803     0xBC, 0x9A, 0x78, 0x56,
 804     0x34, 0x12,
 805     // private flags
 806     0x00,
 807   };
 808   // clang-format on
 809
 810   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
 811   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 812   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
 813   ASSERT_TRUE(visitor_.header_.get());
 814   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
 815             visitor_.header_->public_header.connection_id);
 816   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
 817   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
 818   EXPECT_FALSE(visitor_.header_->fec_flag);
 819   EXPECT_FALSE(visitor_.header_->entropy_flag);
 820   EXPECT_EQ(0, visitor_.header_->entropy_hash);
 821   EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_packet_number);
 822   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
 823   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
 824
 825   // Now test framing boundaries.
 826   for (size_t i = 0;
 827        i < GetPacketHeaderSize(PACKET_0BYTE_CONNECTION_ID, !kIncludeVersion,
 828                                PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
 829        ++i) {
 830     string expected_error;
 831     if (i < kConnectionIdOffset) {
 832       expected_error = "Unable to read public flags.";
 833     } else if (i < GetPacketNumberOffset(PACKET_0BYTE_CONNECTION_ID,
 834                                          !kIncludeVersion)) {
 835       expected_error = "Unable to read ConnectionId.";
 836     } else if (i < GetPrivateFlagsOffset(PACKET_0BYTE_CONNECTION_ID,
 837                                          !kIncludeVersion)) {
 838       expected_error = "Unable to read packet number.";
 839     } else if (i < GetFecGroupOffset(PACKET_0BYTE_CONNECTION_ID,
 840                                      !kIncludeVersion)) {
 841       expected_error = "Unable to read private flags.";
 842     } else {
 843       expected_error = "Unable to read first fec protected packet offset.";
 844     }
 845     CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
 846   }
 847 }
 848
 849 TEST_P(QuicFramerTest, PacketHeaderWithVersionFlag) {
 850   // clang-format off
 851   unsigned char packet[] = {
 852     // public flags (version)
 853     0x3D,
 854     // connection_id
 855     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
 856     // version tag
 857     'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
 858     // packet number
 859     0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
 860     // private flags
 861     0x00,
 862   };
 863   // clang-format on
 864
 865   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
 866   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 867   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
 868   ASSERT_TRUE(visitor_.header_.get());
 869   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
 870             visitor_.header_->public_header.connection_id);
 871   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
 872   EXPECT_TRUE(visitor_.header_->public_header.version_flag);
 873   EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]);
 874   EXPECT_FALSE(visitor_.header_->fec_flag);
 875   EXPECT_FALSE(visitor_.header_->entropy_flag);
 876   EXPECT_EQ(0, visitor_.header_->entropy_hash);
 877   EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_packet_number);
 878   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
 879   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
 880
 881   // Now test framing boundaries.
 882   for (size_t i = 0;
 883        i < GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, kIncludeVersion,
 884                                PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
 885        ++i) {
 886     string expected_error;
 887     if (i < kConnectionIdOffset) {
 888       expected_error = "Unable to read public flags.";
 889     } else if (i < kVersionOffset) {
 890       expected_error = "Unable to read ConnectionId.";
 891     } else if (i < GetPacketNumberOffset(kIncludeVersion)) {
 892       expected_error = "Unable to read protocol version.";
 893     } else if (i < GetPrivateFlagsOffset(kIncludeVersion)) {
 894       expected_error = "Unable to read packet number.";
 895     } else if (i < GetFecGroupOffset(kIncludeVersion)) {
 896       expected_error = "Unable to read private flags.";
 897     } else {
 898       expected_error = "Unable to read first fec protected packet offset.";
 899     }
 900     CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
 901   }
 902 }
 903
 904 TEST_P(QuicFramerTest, PacketHeaderWith4BytePacketNumber) {
 905   QuicFramerPeer::SetLastPacketNumber(&framer_, UINT64_C(0x123456789ABA));
 906
 907   // clang-format off
 908   unsigned char packet[] = {
 909     // public flags (8 byte connection_id and 4 byte packet number)
 910     0x2C,
 911     // connection_id
 912     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
 913     // packet number
 914     0xBC, 0x9A, 0x78, 0x56,
 915     // private flags
 916     0x00,
 917   };
 918   // clang-format on
 919
 920   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
 921   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 922   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
 923   ASSERT_TRUE(visitor_.header_.get());
 924   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
 925             visitor_.header_->public_header.connection_id);
 926   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
 927   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
 928   EXPECT_FALSE(visitor_.header_->fec_flag);
 929   EXPECT_FALSE(visitor_.header_->entropy_flag);
 930   EXPECT_EQ(0, visitor_.header_->entropy_hash);
 931   EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_packet_number);
 932   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
 933   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
 934
 935   // Now test framing boundaries.
 936   for (size_t i = 0;
 937        i < GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
 938                                PACKET_4BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
 939        ++i) {
 940     string expected_error;
 941     if (i < kConnectionIdOffset) {
 942       expected_error = "Unable to read public flags.";
 943     } else if (i < GetPacketNumberOffset(!kIncludeVersion)) {
 944       expected_error = "Unable to read ConnectionId.";
 945     } else if (i < GetPrivateFlagsOffset(!kIncludeVersion,
 946                                          PACKET_4BYTE_PACKET_NUMBER)) {
 947       expected_error = "Unable to read packet number.";
 948     } else if (i < GetFecGroupOffset(!kIncludeVersion,
 949                                      PACKET_4BYTE_PACKET_NUMBER)) {
 950       expected_error = "Unable to read private flags.";
 951     } else {
 952       expected_error = "Unable to read first fec protected packet offset.";
 953     }
 954     CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
 955   }
 956 }
 957
 958 TEST_P(QuicFramerTest, PacketHeaderWith2BytePacketNumber) {
 959   QuicFramerPeer::SetLastPacketNumber(&framer_, UINT64_C(0x123456789ABA));
 960
 961   // clang-format off
 962   unsigned char packet[] = {
 963     // public flags (8 byte connection_id and 2 byte packet number)
 964     0x1C,
 965     // connection_id
 966     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
 967     // packet number
 968     0xBC, 0x9A,
 969     // private flags
 970     0x00,
 971   };
 972   // clang-format on
 973
 974   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
 975   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
 976   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
 977   ASSERT_TRUE(visitor_.header_.get());
 978   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
 979             visitor_.header_->public_header.connection_id);
 980   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
 981   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
 982   EXPECT_FALSE(visitor_.header_->fec_flag);
 983   EXPECT_FALSE(visitor_.header_->entropy_flag);
 984   EXPECT_EQ(0, visitor_.header_->entropy_hash);
 985   EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_packet_number);
 986   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
 987   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
 988
 989   // Now test framing boundaries.
 990   for (size_t i = 0;
 991        i < GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
 992                                PACKET_2BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
 993        ++i) {
 994     string expected_error;
 995     if (i < kConnectionIdOffset) {
 996       expected_error = "Unable to read public flags.";
 997     } else if (i < GetPacketNumberOffset(!kIncludeVersion)) {
 998       expected_error = "Unable to read ConnectionId.";
 999     } else if (i < GetPrivateFlagsOffset(!kIncludeVersion,
1000                                          PACKET_2BYTE_PACKET_NUMBER)) {
1001       expected_error = "Unable to read packet number.";
1002     } else if (i < GetFecGroupOffset(!kIncludeVersion,
1003                                      PACKET_2BYTE_PACKET_NUMBER)) {
1004       expected_error = "Unable to read private flags.";
1005     } else {
1006       expected_error = "Unable to read first fec protected packet offset.";
1007     }
1008     CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
1009   }
1010 }
1011
1012 TEST_P(QuicFramerTest, PacketHeaderWith1BytePacketNumber) {
1013   QuicFramerPeer::SetLastPacketNumber(&framer_, UINT64_C(0x123456789ABA));
1014
1015   // clang-format off
1016   unsigned char packet[] = {
1017     // public flags (8 byte connection_id and 1 byte packet number)
1018     0x0C,
1019     // connection_id
1020     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
1021     // packet number
1022     0xBC,
1023     // private flags
1024     0x00,
1025   };
1026   // clang-format on
1027
1028   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1029   EXPECT_FALSE(framer_.ProcessPacket(encrypted));
1030   EXPECT_EQ(QUIC_MISSING_PAYLOAD, framer_.error());
1031   ASSERT_TRUE(visitor_.header_.get());
1032   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
1033             visitor_.header_->public_header.connection_id);
1034   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
1035   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
1036   EXPECT_FALSE(visitor_.header_->fec_flag);
1037   EXPECT_FALSE(visitor_.header_->entropy_flag);
1038   EXPECT_EQ(0, visitor_.header_->entropy_hash);
1039   EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_packet_number);
1040   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
1041   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
1042
1043   // Now test framing boundaries.
1044   for (size_t i = 0;
1045        i < GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
1046                                PACKET_1BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
1047        ++i) {
1048     string expected_error;
1049     if (i < kConnectionIdOffset) {
1050       expected_error = "Unable to read public flags.";
1051     } else if (i < GetPacketNumberOffset(!kIncludeVersion)) {
1052       expected_error = "Unable to read ConnectionId.";
1053     } else if (i < GetPrivateFlagsOffset(!kIncludeVersion,
1054                                          PACKET_1BYTE_PACKET_NUMBER)) {
1055       expected_error = "Unable to read packet number.";
1056     } else if (i < GetFecGroupOffset(!kIncludeVersion,
1057                                      PACKET_1BYTE_PACKET_NUMBER)) {
1058       expected_error = "Unable to read private flags.";
1059     } else {
1060       expected_error = "Unable to read first fec protected packet offset.";
1061     }
1062     CheckProcessingFails(packet, i, expected_error, QUIC_INVALID_PACKET_HEADER);
1063   }
1064 }
1065
1066 TEST_P(QuicFramerTest, InvalidPublicFlag) {
1067   // clang-format off
1068   unsigned char packet[] = {
1069     // public flags: all flags set but the public reset flag and version flag.
1070     0xFC,
1071     // connection_id
1072     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
1073     // packet number
1074     0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
1075     // private flags
1076     0x00,
1077
1078     // frame type (padding)
1079     0x00,
1080     0x00, 0x00, 0x00, 0x00
1081   };
1082   // clang-format on
1083
1084   CheckProcessingFails(packet,
1085                        arraysize(packet),
1086                        "Illegal public flags value.",
1087                        QUIC_INVALID_PACKET_HEADER);
1088
1089   // Now turn off validation.
1090   framer_.set_validate_flags(false);
1091   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1092   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1093 };
1094
1095 TEST_P(QuicFramerTest, InvalidPublicFlagWithMatchingVersions) {
1096   // clang-format off
1097   unsigned char packet[] = {
1098     // public flags (8 byte connection_id and version flag and an unknown flag)
1099     0x4D,
1100     // connection_id
1101     0x10, 0x32, 0x54, 0x76,
1102     0x98, 0xBA, 0xDC, 0xFE,
1103     // version tag
1104     'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
1105     // packet number
1106     0xBC, 0x9A, 0x78, 0x56,
1107     0x34, 0x12,
1108     // private flags
1109     0x00,
1110
1111     // frame type (padding)
1112     0x00,
1113     0x00, 0x00, 0x00, 0x00
1114   };
1115   // clang-format on
1116   CheckProcessingFails(packet,
1117                        arraysize(packet),
1118                        "Illegal public flags value.",
1119                        QUIC_INVALID_PACKET_HEADER);
1120 };
1121
1122 TEST_P(QuicFramerTest, LargePublicFlagWithMismatchedVersions) {
1123   // clang-format off
1124   unsigned char packet[] = {
1125     // public flags (8 byte connection_id, version flag and an unknown flag)
1126     0x7D,
1127     // connection_id
1128     0x10, 0x32, 0x54, 0x76,
1129     0x98, 0xBA, 0xDC, 0xFE,
1130     // version tag
1131     'Q', '0', '0', '0',
1132     // packet number
1133     0xBC, 0x9A, 0x78, 0x56,
1134     0x34, 0x12,
1135     // private flags
1136     0x00,
1137
1138     // frame type (padding frame)
1139     0x00,
1140     0x00, 0x00, 0x00, 0x00
1141   };
1142   // clang-format on
1143   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1144   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1145   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1146   ASSERT_TRUE(visitor_.header_.get());
1147   EXPECT_EQ(0, visitor_.frame_count_);
1148   EXPECT_EQ(1, visitor_.version_mismatch_);
1149 };
1150
1151 TEST_P(QuicFramerTest, InvalidPrivateFlag) {
1152   // clang-format off
1153   unsigned char packet[] = {
1154     // public flags (8 byte connection_id)
1155     0x3C,
1156     // connection_id
1157     0x10, 0x32, 0x54, 0x76,
1158     0x98, 0xBA, 0xDC, 0xFE,
1159     // packet number
1160     0xBC, 0x9A, 0x78, 0x56,
1161     0x34, 0x12,
1162     // private flags
1163     0x10,
1164
1165     // frame type (padding)
1166     0x00,
1167     0x00, 0x00, 0x00, 0x00
1168   };
1169   // clang-format on
1170   CheckProcessingFails(packet,
1171                        arraysize(packet),
1172                        "Illegal private flags value.",
1173                        QUIC_INVALID_PACKET_HEADER);
1174 };
1175
1176 TEST_P(QuicFramerTest, InvalidFECGroupOffset) {
1177   // clang-format off
1178   unsigned char packet[] = {
1179     // public flags (8 byte connection_id)
1180     0x3C,
1181     // connection_id
1182     0x10, 0x32, 0x54, 0x76,
1183     0x98, 0xBA, 0xDC, 0xFE,
1184     // packet number
1185     0x01, 0x00, 0x00, 0x00,
1186     0x00, 0x00,
1187     // private flags (fec group)
1188     0x02,
1189     // first fec protected packet offset
1190     0x10
1191   };
1192   // clang-format on
1193   CheckProcessingFails(packet, arraysize(packet),
1194                        "First fec protected packet offset must be less "
1195                        "than the packet number.",
1196                        QUIC_INVALID_PACKET_HEADER);
1197 };
1198
1199 TEST_P(QuicFramerTest, PaddingFrame) {
1200   // clang-format off
1201   unsigned char packet[] = {
1202     // public flags (8 byte connection_id)
1203     0x3C,
1204     // connection_id
1205     0x10, 0x32, 0x54, 0x76,
1206     0x98, 0xBA, 0xDC, 0xFE,
1207     // packet number
1208     0xBC, 0x9A, 0x78, 0x56,
1209     0x34, 0x12,
1210     // private flags
1211     0x00,
1212
1213     // frame type (padding frame)
1214     0x00,
1215     // Ignored data (which in this case is a stream frame)
1216     // frame type (stream frame with fin)
1217     0xFF,
1218     // stream id
1219     0x04, 0x03, 0x02, 0x01,
1220     // offset
1221     0x54, 0x76, 0x10, 0x32,
1222     0xDC, 0xFE, 0x98, 0xBA,
1223     // data length
1224     0x0c, 0x00,
1225     // data
1226     'h',  'e',  'l',  'l',
1227     'o',  ' ',  'w',  'o',
1228     'r',  'l',  'd',  '!',
1229   };
1230   // clang-format on
1231
1232   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1233   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1234   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1235   ASSERT_TRUE(visitor_.header_.get());
1236   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1237
1238   ASSERT_EQ(0u, visitor_.stream_frames_.size());
1239   EXPECT_EQ(0u, visitor_.ack_frames_.size());
1240   // A packet with no frames is not acceptable.
1241   CheckProcessingFails(
1242       packet, GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
1243                                   PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
1244       "Packet has no frames.", QUIC_MISSING_PAYLOAD);
1245 }
1246
1247 TEST_P(QuicFramerTest, StreamFrame) {
1248   // clang-format off
1249   unsigned char packet[] = {
1250     // public flags (8 byte connection_id)
1251     0x3C,
1252     // connection_id
1253     0x10, 0x32, 0x54, 0x76,
1254     0x98, 0xBA, 0xDC, 0xFE,
1255     // packet number
1256     0xBC, 0x9A, 0x78, 0x56,
1257     0x34, 0x12,
1258     // private flags
1259     0x00,
1260
1261     // frame type (stream frame with fin)
1262     0xFF,
1263     // stream id
1264     0x04, 0x03, 0x02, 0x01,
1265     // offset
1266     0x54, 0x76, 0x10, 0x32,
1267     0xDC, 0xFE, 0x98, 0xBA,
1268     // data length
1269     0x0c, 0x00,
1270     // data
1271     'h',  'e',  'l',  'l',
1272     'o',  ' ',  'w',  'o',
1273     'r',  'l',  'd',  '!',
1274   };
1275   // clang-format on
1276
1277   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1278   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1279
1280   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1281   ASSERT_TRUE(visitor_.header_.get());
1282   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1283
1284   ASSERT_EQ(1u, visitor_.stream_frames_.size());
1285   EXPECT_EQ(0u, visitor_.ack_frames_.size());
1286   EXPECT_EQ(static_cast<uint64>(0x01020304),
1287             visitor_.stream_frames_[0]->stream_id);
1288   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1289   EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
1290   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1291
1292   // Now test framing boundaries.
1293   CheckStreamFrameBoundaries(packet, kQuicMaxStreamIdSize, !kIncludeVersion);
1294 }
1295
1296 TEST_P(QuicFramerTest, StreamFrame3ByteStreamId) {
1297   // clang-format off
1298   unsigned char packet[] = {
1299     // public flags (8 byte connection_id)
1300     0x3C,
1301     // connection_id
1302     0x10, 0x32, 0x54, 0x76,
1303     0x98, 0xBA, 0xDC, 0xFE,
1304     // packet number
1305     0xBC, 0x9A, 0x78, 0x56,
1306     0x34, 0x12,
1307     // private flags
1308     0x00,
1309
1310     // frame type (stream frame with fin)
1311     0xFE,
1312     // stream id
1313     0x04, 0x03, 0x02,
1314     // offset
1315     0x54, 0x76, 0x10, 0x32,
1316     0xDC, 0xFE, 0x98, 0xBA,
1317     // data length
1318     0x0c, 0x00,
1319     // data
1320     'h',  'e',  'l',  'l',
1321     'o',  ' ',  'w',  'o',
1322     'r',  'l',  'd',  '!',
1323   };
1324   // clang-format on
1325
1326   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1327   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1328
1329   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1330   ASSERT_TRUE(visitor_.header_.get());
1331   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1332
1333   ASSERT_EQ(1u, visitor_.stream_frames_.size());
1334   EXPECT_EQ(0u, visitor_.ack_frames_.size());
1335   EXPECT_EQ(UINT64_C(0x00020304), visitor_.stream_frames_[0]->stream_id);
1336   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1337   EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
1338   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1339
1340   // Now test framing boundaries.
1341   const size_t stream_id_size = 3;
1342   CheckStreamFrameBoundaries(packet, stream_id_size, !kIncludeVersion);
1343 }
1344
1345 TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) {
1346   // clang-format off
1347   unsigned char packet[] = {
1348     // public flags (8 byte connection_id)
1349     0x3C,
1350     // connection_id
1351     0x10, 0x32, 0x54, 0x76,
1352     0x98, 0xBA, 0xDC, 0xFE,
1353     // packet number
1354     0xBC, 0x9A, 0x78, 0x56,
1355     0x34, 0x12,
1356     // private flags
1357     0x00,
1358
1359     // frame type (stream frame with fin)
1360     0xFD,
1361     // stream id
1362     0x04, 0x03,
1363     // offset
1364     0x54, 0x76, 0x10, 0x32,
1365     0xDC, 0xFE, 0x98, 0xBA,
1366     // data length
1367     0x0c, 0x00,
1368     // data
1369     'h',  'e',  'l',  'l',
1370     'o',  ' ',  'w',  'o',
1371     'r',  'l',  'd',  '!',
1372   };
1373   // clang-format on
1374
1375   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1376   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1377
1378   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1379   ASSERT_TRUE(visitor_.header_.get());
1380   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1381
1382   ASSERT_EQ(1u, visitor_.stream_frames_.size());
1383   EXPECT_EQ(0u, visitor_.ack_frames_.size());
1384   EXPECT_EQ(static_cast<uint64>(0x00000304),
1385             visitor_.stream_frames_[0]->stream_id);
1386   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1387   EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
1388   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1389
1390   // Now test framing boundaries.
1391   const size_t stream_id_size = 2;
1392   CheckStreamFrameBoundaries(packet, stream_id_size, !kIncludeVersion);
1393 }
1394
1395 TEST_P(QuicFramerTest, StreamFrame1ByteStreamId) {
1396   // clang-format off
1397   unsigned char packet[] = {
1398     // public flags (8 byte connection_id)
1399     0x3C,
1400     // connection_id
1401     0x10, 0x32, 0x54, 0x76,
1402     0x98, 0xBA, 0xDC, 0xFE,
1403     // packet number
1404     0xBC, 0x9A, 0x78, 0x56,
1405     0x34, 0x12,
1406     // private flags
1407     0x00,
1408
1409     // frame type (stream frame with fin)
1410     0xFC,
1411     // stream id
1412     0x04,
1413     // offset
1414     0x54, 0x76, 0x10, 0x32,
1415     0xDC, 0xFE, 0x98, 0xBA,
1416     // data length
1417     0x0c, 0x00,
1418     // data
1419     'h',  'e',  'l',  'l',
1420     'o',  ' ',  'w',  'o',
1421     'r',  'l',  'd',  '!',
1422   };
1423   // clang-format on
1424
1425   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1426   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1427
1428   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1429   ASSERT_TRUE(visitor_.header_.get());
1430   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1431
1432   ASSERT_EQ(1u, visitor_.stream_frames_.size());
1433   EXPECT_EQ(0u, visitor_.ack_frames_.size());
1434   EXPECT_EQ(static_cast<uint64>(0x00000004),
1435             visitor_.stream_frames_[0]->stream_id);
1436   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1437   EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
1438   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1439
1440   // Now test framing boundaries.
1441   const size_t stream_id_size = 1;
1442   CheckStreamFrameBoundaries(packet, stream_id_size, !kIncludeVersion);
1443 }
1444
1445 TEST_P(QuicFramerTest, StreamFrameWithVersion) {
1446   // clang-format off
1447   unsigned char packet[] = {
1448     // public flags (version, 8 byte connection_id)
1449     0x3D,
1450     // connection_id
1451     0x10, 0x32, 0x54, 0x76,
1452     0x98, 0xBA, 0xDC, 0xFE,
1453     // version tag
1454     'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
1455     // packet number
1456     0xBC, 0x9A, 0x78, 0x56,
1457     0x34, 0x12,
1458     // private flags
1459     0x00,
1460
1461     // frame type (stream frame with fin)
1462     0xFF,
1463     // stream id
1464     0x04, 0x03, 0x02, 0x01,
1465     // offset
1466     0x54, 0x76, 0x10, 0x32,
1467     0xDC, 0xFE, 0x98, 0xBA,
1468     // data length
1469     0x0c, 0x00,
1470     // data
1471     'h',  'e',  'l',  'l',
1472     'o',  ' ',  'w',  'o',
1473     'r',  'l',  'd',  '!',
1474   };
1475   // clang-format on
1476
1477   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1478   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1479
1480   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1481   ASSERT_TRUE(visitor_.header_.get());
1482   EXPECT_TRUE(visitor_.header_->public_header.version_flag);
1483   EXPECT_EQ(GetParam(), visitor_.header_->public_header.versions[0]);
1484   EXPECT_TRUE(CheckDecryption(encrypted, kIncludeVersion));
1485
1486   ASSERT_EQ(1u, visitor_.stream_frames_.size());
1487   EXPECT_EQ(0u, visitor_.ack_frames_.size());
1488   EXPECT_EQ(static_cast<uint64>(0x01020304),
1489             visitor_.stream_frames_[0]->stream_id);
1490   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1491   EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
1492   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1493
1494   // Now test framing boundaries.
1495   CheckStreamFrameBoundaries(packet, kQuicMaxStreamIdSize, kIncludeVersion);
1496 }
1497
1498 TEST_P(QuicFramerTest, RejectPacket) {
1499   visitor_.accept_packet_ = false;
1500
1501   // clang-format off
1502   unsigned char packet[] = {
1503     // public flags (8 byte connection_id)
1504     0x3C,
1505     // connection_id
1506     0x10, 0x32, 0x54, 0x76,
1507     0x98, 0xBA, 0xDC, 0xFE,
1508     // packet number
1509     0xBC, 0x9A, 0x78, 0x56,
1510     0x34, 0x12,
1511     // private flags
1512     0x00,
1513
1514     // frame type (stream frame with fin)
1515     0xFF,
1516     // stream id
1517     0x04, 0x03, 0x02, 0x01,
1518     // offset
1519     0x54, 0x76, 0x10, 0x32,
1520     0xDC, 0xFE, 0x98, 0xBA,
1521     // data length
1522     0x0c, 0x00,
1523     // data
1524     'h',  'e',  'l',  'l',
1525     'o',  ' ',  'w',  'o',
1526     'r',  'l',  'd',  '!',
1527   };
1528   // clang-format on
1529
1530   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1531   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1532
1533   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1534   ASSERT_TRUE(visitor_.header_.get());
1535   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1536
1537   ASSERT_EQ(0u, visitor_.stream_frames_.size());
1538   EXPECT_EQ(0u, visitor_.ack_frames_.size());
1539 }
1540
1541 TEST_P(QuicFramerTest, RejectPublicHeader) {
1542   visitor_.accept_public_header_ = false;
1543
1544   // clang-format off
1545   unsigned char packet[] = {
1546     // public flags (8 byte connection_id)
1547     0x3C,
1548     // connection_id
1549     0x10, 0x32, 0x54, 0x76,
1550     0x98, 0xBA, 0xDC, 0xFE,
1551   };
1552   // clang-format on
1553
1554   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1555   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1556
1557   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1558   ASSERT_TRUE(visitor_.public_header_.get());
1559   ASSERT_FALSE(visitor_.header_.get());
1560 }
1561
1562 TEST_P(QuicFramerTest, RevivedStreamFrame) {
1563   // clang-format off
1564   unsigned char payload[] = {
1565     // frame type (stream frame with fin)
1566     0xFF,
1567     // stream id
1568     0x04, 0x03, 0x02, 0x01,
1569     // offset
1570     0x54, 0x76, 0x10, 0x32,
1571     0xDC, 0xFE, 0x98, 0xBA,
1572     // data length
1573     0x0c, 0x00,
1574     // data
1575     'h',  'e',  'l',  'l',
1576     'o',  ' ',  'w',  'o',
1577     'r',  'l',  'd',  '!',
1578   };
1579   // clang-format on
1580
1581   QuicPacketHeader header;
1582   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
1583   header.public_header.reset_flag = false;
1584   header.public_header.version_flag = false;
1585   header.fec_flag = true;
1586   header.entropy_flag = true;
1587   header.packet_packet_number = UINT64_C(0x123456789ABC);
1588   header.fec_group = 0;
1589
1590   // Do not encrypt the payload because the revived payload is post-encryption.
1591   EXPECT_TRUE(framer_.ProcessRevivedPacket(&header,
1592                                            StringPiece(AsChars(payload),
1593                                                        arraysize(payload))));
1594
1595   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1596   ASSERT_EQ(1, visitor_.revived_packets_);
1597   ASSERT_TRUE(visitor_.header_.get());
1598   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
1599             visitor_.header_->public_header.connection_id);
1600   EXPECT_FALSE(visitor_.header_->public_header.reset_flag);
1601   EXPECT_FALSE(visitor_.header_->public_header.version_flag);
1602   EXPECT_TRUE(visitor_.header_->fec_flag);
1603   EXPECT_TRUE(visitor_.header_->entropy_flag);
1604   EXPECT_EQ(1 << (header.packet_packet_number % 8),
1605             visitor_.header_->entropy_hash);
1606   EXPECT_EQ(UINT64_C(0x123456789ABC), visitor_.header_->packet_packet_number);
1607   EXPECT_EQ(NOT_IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
1608   EXPECT_EQ(0x00u, visitor_.header_->fec_group);
1609
1610   ASSERT_EQ(1u, visitor_.stream_frames_.size());
1611   EXPECT_EQ(0u, visitor_.ack_frames_.size());
1612   EXPECT_EQ(UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id);
1613   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1614   EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
1615   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1616 }
1617
1618 TEST_P(QuicFramerTest, StreamFrameInFecGroup) {
1619   // clang-format off
1620   unsigned char packet[] = {
1621     // public flags (8 byte connection_id)
1622     0x3C,
1623     // connection_id
1624     0x10, 0x32, 0x54, 0x76,
1625     0x98, 0xBA, 0xDC, 0xFE,
1626     // packet number
1627     0xBC, 0x9A, 0x78, 0x56,
1628     0x12, 0x34,
1629     // private flags (fec group)
1630     0x02,
1631     // first fec protected packet offset
1632     0x02,
1633
1634     // frame type (stream frame with fin)
1635     0xFF,
1636     // stream id
1637     0x04, 0x03, 0x02, 0x01,
1638     // offset
1639     0x54, 0x76, 0x10, 0x32,
1640     0xDC, 0xFE, 0x98, 0xBA,
1641     // data length
1642     0x0c, 0x00,
1643     // data
1644     'h',  'e',  'l',  'l',
1645     'o',  ' ',  'w',  'o',
1646     'r',  'l',  'd',  '!',
1647   };
1648   // clang-format on
1649
1650   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1651   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1652
1653   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1654   ASSERT_TRUE(visitor_.header_.get());
1655   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1656   EXPECT_EQ(IN_FEC_GROUP, visitor_.header_->is_in_fec_group);
1657   EXPECT_EQ(UINT64_C(0x341256789ABA), visitor_.header_->fec_group);
1658   const size_t fec_offset = GetStartOfFecProtectedData(
1659       PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion, PACKET_6BYTE_PACKET_NUMBER);
1660   EXPECT_EQ(
1661       string(AsChars(packet) + fec_offset, arraysize(packet) - fec_offset),
1662       visitor_.fec_protected_payload_);
1663
1664   ASSERT_EQ(1u, visitor_.stream_frames_.size());
1665   EXPECT_EQ(0u, visitor_.ack_frames_.size());
1666   EXPECT_EQ(UINT64_C(0x01020304), visitor_.stream_frames_[0]->stream_id);
1667   EXPECT_TRUE(visitor_.stream_frames_[0]->fin);
1668   EXPECT_EQ(UINT64_C(0xBA98FEDC32107654), visitor_.stream_frames_[0]->offset);
1669   CheckStreamFrameData("hello world!", visitor_.stream_frames_[0]);
1670 }
1671
1672 TEST_P(QuicFramerTest, AckFrameTwoTimestamp) {
1673   // clang-format off
1674   unsigned char packet[] = {
1675     // public flags (8 byte connection_id)
1676     0x3C,
1677     // connection_id
1678     0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
1679     // packet number
1680     0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
1681     // private flags (entropy)
1682     0x01,
1683
1684     // frame type (ack frame)
1685     // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
1686     0x6C,
1687     // entropy hash of all received packets.
1688     0xBA,
1689     // largest observed packet number
1690     0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
1691     // Zero delta time.
1692     0x00, 0x00,
1693     // Number of timestamps.
1694     0x02,
1695     // Delta from largest observed.
1696     0x01,
1697     // Delta time.
1698     0x10, 0x32, 0x54, 0x76,
1699     // Delta from largest observed.
1700     0x02,
1701     // Delta time.
1702     0x10, 0x32,
1703     // num missing packets
1704     0x01,
1705     // missing packet delta
1706     0x01,
1707     // 0 more missing packets in range.
1708     0x00,
1709     // Number of revived packets.
1710     0x00,
1711   };
1712   // clang-format on
1713
1714   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1715   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1716
1717   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1718   ASSERT_TRUE(visitor_.header_.get());
1719   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1720
1721   EXPECT_EQ(0u, visitor_.stream_frames_.size());
1722   ASSERT_EQ(1u, visitor_.ack_frames_.size());
1723   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
1724   EXPECT_EQ(0xBA, frame.entropy_hash);
1725   EXPECT_EQ(UINT64_C(0x0123456789ABF), frame.largest_observed);
1726   ASSERT_EQ(1u, frame.missing_packets.NumPackets());
1727   ASSERT_EQ(2u, frame.received_packet_times.size());
1728   EXPECT_EQ(UINT64_C(0x0123456789ABE), frame.missing_packets.Min());
1729
1730   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
1731   const size_t kLargestObservedOffset = kReceivedEntropyOffset +
1732       kQuicEntropyHashSize;
1733   const size_t kMissingDeltaTimeOffset =
1734       kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
1735   const size_t kNumTimestampsOffset =
1736       kMissingDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
1737   const size_t kTimestampDeltaLargestObserved1 =
1738       kNumTimestampsOffset + kQuicNumTimestampsSize;
1739   const size_t kTimestampTimeDeltaLargestObserved1 =
1740       kTimestampDeltaLargestObserved1 + 1;
1741   const size_t kTimestampDeltaLargestObserved2 =
1742       kTimestampTimeDeltaLargestObserved1 + 4;
1743   const size_t kTimestampTimeDeltaLargestObserved2 =
1744       kTimestampDeltaLargestObserved2 + 1;
1745   const size_t kNumMissingPacketOffset =
1746       kTimestampTimeDeltaLargestObserved2 + 2;
1747   const size_t kMissingPacketsOffset =
1748       kNumMissingPacketOffset + kNumberOfNackRangesSize;
1749   const size_t kMissingPacketsRange =
1750       kMissingPacketsOffset + PACKET_1BYTE_PACKET_NUMBER;
1751   const size_t kRevivedPacketsLength =
1752       kMissingPacketsRange + PACKET_1BYTE_PACKET_NUMBER;
1753   // Now test framing boundaries.
1754   const size_t ack_frame_size =
1755       kRevivedPacketsLength + PACKET_1BYTE_PACKET_NUMBER;
1756   for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
1757     string expected_error;
1758     if (i < kLargestObservedOffset) {
1759       expected_error = "Unable to read entropy hash for received packets.";
1760     } else if (i < kMissingDeltaTimeOffset) {
1761       expected_error = "Unable to read largest observed.";
1762     } else if (i < kNumTimestampsOffset) {
1763       expected_error = "Unable to read delta time largest observed.";
1764     } else if (i < kTimestampDeltaLargestObserved1) {
1765       expected_error = "Unable to read num received packets.";
1766     } else if (i < kTimestampTimeDeltaLargestObserved1) {
1767       expected_error = "Unable to read sequence delta in received packets.";
1768     } else if (i < kTimestampDeltaLargestObserved2) {
1769       expected_error = "Unable to read time delta in received packets.";
1770     } else if (i < kTimestampTimeDeltaLargestObserved2) {
1771       expected_error = "Unable to read sequence delta in received packets.";
1772     } else if (i < kNumMissingPacketOffset) {
1773       expected_error =
1774           "Unable to read incremental time delta in received packets.";
1775     } else if (i < kMissingPacketsOffset) {
1776       expected_error = "Unable to read num missing packet ranges.";
1777     } else if (i < kMissingPacketsRange) {
1778       expected_error = "Unable to read missing packet number delta.";
1779     } else if (i < kRevivedPacketsLength) {
1780       expected_error = "Unable to read missing packet number range.";
1781     } else {
1782       expected_error = "Unable to read num revived packets.";
1783     }
1784     CheckProcessingFails(
1785         packet,
1786         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
1787                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
1788         expected_error, QUIC_INVALID_ACK_DATA);
1789   }
1790 }
1791
1792 TEST_P(QuicFramerTest, AckFrameOneTimestamp) {
1793   // clang-format off
1794   unsigned char packet[] = {
1795       // public flags (8 byte connection_id)
1796       0x3C,
1797       // connection_id
1798       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
1799       // packet number
1800       0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
1801       // private flags (entropy)
1802       0x01,
1803
1804       // frame type (ack frame)
1805       // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
1806       0x6C,
1807       // entropy hash of all received packets.
1808       0xBA,
1809       // largest observed packet number
1810       0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
1811       // Zero delta time.
1812       0x00, 0x00,
1813       // Number of timestamps.
1814       0x01,
1815       // Delta from largest observed.
1816       0x01,
1817       // Delta time.
1818       0x10, 0x32, 0x54, 0x76,
1819       // num missing packets
1820       0x01,
1821       // missing packet delta
1822       0x01,
1823       // 0 more missing packets in range.
1824       0x00,
1825       // Number of revived packets.
1826       0x00,
1827   };
1828   // clang-format on
1829
1830   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1831   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1832
1833   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1834   ASSERT_TRUE(visitor_.header_.get());
1835   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1836
1837   EXPECT_EQ(0u, visitor_.stream_frames_.size());
1838   ASSERT_EQ(1u, visitor_.ack_frames_.size());
1839   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
1840   EXPECT_EQ(0xBA, frame.entropy_hash);
1841   EXPECT_EQ(UINT64_C(0x0123456789ABF), frame.largest_observed);
1842   ASSERT_EQ(1u, frame.missing_packets.NumPackets());
1843   ASSERT_EQ(1u, frame.received_packet_times.size());
1844   EXPECT_EQ(UINT64_C(0x0123456789ABE), frame.missing_packets.Min());
1845
1846   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
1847   const size_t kLargestObservedOffset =
1848       kReceivedEntropyOffset + kQuicEntropyHashSize;
1849   const size_t kMissingDeltaTimeOffset =
1850       kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
1851   const size_t kNumTimestampsOffset =
1852       kMissingDeltaTimeOffset + kQuicDeltaTimeLargestObservedSize;
1853   const size_t kTimestampDeltaLargestObserved =
1854       kNumTimestampsOffset + kQuicNumTimestampsSize;
1855   const size_t kTimestampTimeDeltaLargestObserved =
1856     kTimestampDeltaLargestObserved + 1;
1857   const size_t kNumMissingPacketOffset = kTimestampTimeDeltaLargestObserved + 4;
1858   const size_t kMissingPacketsOffset =
1859       kNumMissingPacketOffset + kNumberOfNackRangesSize;
1860   const size_t kMissingPacketsRange =
1861       kMissingPacketsOffset + PACKET_1BYTE_PACKET_NUMBER;
1862   const size_t kRevivedPacketsLength =
1863       kMissingPacketsRange + PACKET_1BYTE_PACKET_NUMBER;
1864   // Now test framing boundaries.
1865   const size_t ack_frame_size =
1866       kRevivedPacketsLength + PACKET_1BYTE_PACKET_NUMBER;
1867   for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
1868     string expected_error;
1869     if (i < kLargestObservedOffset) {
1870       expected_error = "Unable to read entropy hash for received packets.";
1871     } else if (i < kMissingDeltaTimeOffset) {
1872       expected_error = "Unable to read largest observed.";
1873     } else if (i < kNumTimestampsOffset) {
1874       expected_error = "Unable to read delta time largest observed.";
1875     } else if (i < kTimestampDeltaLargestObserved) {
1876       expected_error = "Unable to read num received packets.";
1877     } else if (i < kTimestampTimeDeltaLargestObserved) {
1878       expected_error = "Unable to read sequence delta in received packets.";
1879     } else if (i < kNumMissingPacketOffset) {
1880       expected_error = "Unable to read time delta in received packets.";
1881     } else if (i < kMissingPacketsOffset) {
1882       expected_error = "Unable to read num missing packet ranges.";
1883     } else if (i < kMissingPacketsRange) {
1884       expected_error = "Unable to read missing packet number delta.";
1885     } else if (i < kRevivedPacketsLength) {
1886       expected_error = "Unable to read missing packet number range.";
1887     } else {
1888       expected_error = "Unable to read num revived packets.";
1889     }
1890     CheckProcessingFails(
1891         packet,
1892         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
1893                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
1894         expected_error, QUIC_INVALID_ACK_DATA);
1895   }
1896 }
1897
1898 TEST_P(QuicFramerTest, AckFrame) {
1899   // clang-format off
1900   unsigned char packet[] = {
1901       // public flags (8 byte connection_id)
1902       0x3C,
1903       // connection_id
1904       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
1905       // packet number
1906       0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
1907       // private flags (entropy)
1908       0x01,
1909
1910       // frame type (ack frame)
1911       // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
1912       0x6C,
1913       // entropy hash of all received packets.
1914       0xBA,
1915       // largest observed packet number
1916       0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
1917       // Zero delta time.
1918       0x00, 0x00,
1919       // Number of timestamps.
1920       0x00,
1921       // num missing packets
1922       0x01,
1923       // missing packet delta
1924       0x01,
1925       // 0 more missing packets in range.
1926       0x00,
1927       // Number of revived packets.
1928       0x00,
1929   };
1930   // clang-format on
1931
1932   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
1933   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
1934
1935   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
1936   ASSERT_TRUE(visitor_.header_.get());
1937   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
1938
1939   EXPECT_EQ(0u, visitor_.stream_frames_.size());
1940   ASSERT_EQ(1u, visitor_.ack_frames_.size());
1941   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
1942   EXPECT_EQ(0xBA, frame.entropy_hash);
1943   EXPECT_EQ(UINT64_C(0x0123456789ABF), frame.largest_observed);
1944   ASSERT_EQ(1u, frame.missing_packets.NumPackets());
1945   EXPECT_EQ(UINT64_C(0x0123456789ABE), frame.missing_packets.Min());
1946
1947   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
1948   const size_t kLargestObservedOffset = kReceivedEntropyOffset +
1949       kQuicEntropyHashSize;
1950   const size_t kMissingDeltaTimeOffset =
1951       kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
1952   const size_t kNumTimestampsOffset = kMissingDeltaTimeOffset +
1953       kQuicDeltaTimeLargestObservedSize;
1954   const size_t kNumMissingPacketOffset = kNumTimestampsOffset +
1955       kQuicNumTimestampsSize;
1956   const size_t kMissingPacketsOffset = kNumMissingPacketOffset +
1957       kNumberOfNackRangesSize;
1958   const size_t kMissingPacketsRange =
1959       kMissingPacketsOffset + PACKET_1BYTE_PACKET_NUMBER;
1960   const size_t kRevivedPacketsLength =
1961       kMissingPacketsRange + PACKET_1BYTE_PACKET_NUMBER;
1962   // Now test framing boundaries.
1963   const size_t ack_frame_size =
1964       kRevivedPacketsLength + PACKET_1BYTE_PACKET_NUMBER;
1965   for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
1966     string expected_error;
1967     if (i < kLargestObservedOffset) {
1968       expected_error = "Unable to read entropy hash for received packets.";
1969     } else if (i < kMissingDeltaTimeOffset) {
1970       expected_error = "Unable to read largest observed.";
1971     } else if (i < kNumTimestampsOffset) {
1972       expected_error = "Unable to read delta time largest observed.";
1973     } else if (i < kNumMissingPacketOffset) {
1974       expected_error = "Unable to read num received packets.";
1975     } else if (i < kMissingPacketsOffset) {
1976       expected_error = "Unable to read num missing packet ranges.";
1977     } else if (i < kMissingPacketsRange) {
1978       expected_error = "Unable to read missing packet number delta.";
1979     } else if (i < kRevivedPacketsLength) {
1980       expected_error = "Unable to read missing packet number range.";
1981     } else {
1982       expected_error = "Unable to read num revived packets.";
1983     }
1984     CheckProcessingFails(
1985         packet,
1986         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
1987                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
1988         expected_error, QUIC_INVALID_ACK_DATA);
1989   }
1990 }
1991
1992 TEST_P(QuicFramerTest, AckFrameRevivedPackets) {
1993   // clang-format off
1994   unsigned char packet[] = {
1995       // public flags (8 byte connection_id)
1996       0x3C,
1997       // connection_id
1998       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
1999       // packet number
2000       0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
2001       // private flags (entropy)
2002       0x01,
2003
2004       // frame type (ack frame)
2005       // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
2006       0x6C,
2007       // entropy hash of all received packets.
2008       0xBA,
2009       // largest observed packet number
2010       0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
2011       // Zero delta time.
2012       0x00, 0x00,
2013       // num received packets.
2014       0x00,
2015       // num missing packets
2016       0x01,
2017       // missing packet delta
2018       0x01,
2019       // 0 more missing packets in range.
2020       0x00,
2021       // Number of revived packets.
2022       0x01,
2023       // Revived packet number.
2024       0xBE, 0x9A, 0x78, 0x56, 0x34, 0x12,
2025       // Number of revived packets.
2026       0x00,
2027   };
2028   // clang-format on
2029
2030   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2031   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2032
2033   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2034   ASSERT_TRUE(visitor_.header_.get());
2035   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2036
2037   EXPECT_EQ(0u, visitor_.stream_frames_.size());
2038   ASSERT_EQ(1u, visitor_.ack_frames_.size());
2039   const QuicAckFrame& frame = *visitor_.ack_frames_[0];
2040   EXPECT_EQ(0xBA, frame.entropy_hash);
2041   EXPECT_EQ(UINT64_C(0x0123456789ABF), frame.largest_observed);
2042   ASSERT_EQ(1u, frame.missing_packets.NumPackets());
2043   EXPECT_EQ(UINT64_C(0x0123456789ABE), frame.missing_packets.Min());
2044
2045   const size_t kReceivedEntropyOffset = kQuicFrameTypeSize;
2046   const size_t kLargestObservedOffset = kReceivedEntropyOffset +
2047       kQuicEntropyHashSize;
2048   const size_t kMissingDeltaTimeOffset =
2049       kLargestObservedOffset + PACKET_6BYTE_PACKET_NUMBER;
2050   const size_t kNumTimestampsOffset = kMissingDeltaTimeOffset +
2051       kQuicDeltaTimeLargestObservedSize;
2052   const size_t kNumMissingPacketOffset = kNumTimestampsOffset +
2053       kQuicNumTimestampsSize;
2054   const size_t kMissingPacketsOffset = kNumMissingPacketOffset +
2055       kNumberOfNackRangesSize;
2056   const size_t kMissingPacketsRange =
2057       kMissingPacketsOffset + PACKET_1BYTE_PACKET_NUMBER;
2058   const size_t kRevivedPacketsLength =
2059       kMissingPacketsRange + PACKET_1BYTE_PACKET_NUMBER;
2060   const size_t kRevivedPacketSequenceNumberLength =
2061       kRevivedPacketsLength + PACKET_1BYTE_PACKET_NUMBER;
2062   // Now test framing boundaries.
2063   const size_t ack_frame_size =
2064       kRevivedPacketSequenceNumberLength + PACKET_6BYTE_PACKET_NUMBER;
2065   for (size_t i = kQuicFrameTypeSize; i < ack_frame_size; ++i) {
2066     string expected_error;
2067     if (i < kReceivedEntropyOffset) {
2068       expected_error = "Unable to read least unacked delta.";
2069     } else if (i < kLargestObservedOffset) {
2070       expected_error = "Unable to read entropy hash for received packets.";
2071     } else if (i < kMissingDeltaTimeOffset) {
2072       expected_error = "Unable to read largest observed.";
2073     } else if (i < kNumTimestampsOffset) {
2074       expected_error = "Unable to read delta time largest observed.";
2075     } else if (i < kNumMissingPacketOffset) {
2076       expected_error = "Unable to read num received packets.";
2077     } else if (i < kMissingPacketsOffset) {
2078       expected_error = "Unable to read num missing packet ranges.";
2079     } else if (i < kMissingPacketsRange) {
2080       expected_error = "Unable to read missing packet number delta.";
2081     } else if (i < kRevivedPacketsLength) {
2082       expected_error = "Unable to read missing packet number range.";
2083     } else if (i < kRevivedPacketSequenceNumberLength) {
2084       expected_error = "Unable to read num revived packets.";
2085     } else {
2086       expected_error = "Unable to read revived packet.";
2087     }
2088     CheckProcessingFails(
2089         packet,
2090         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
2091                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
2092         expected_error, QUIC_INVALID_ACK_DATA);
2093   }
2094 }
2095
2096 TEST_P(QuicFramerTest, AckFrameNoNacks) {
2097   // clang-format off
2098   unsigned char packet[] = {
2099       // public flags (8 byte connection_id)
2100       0x3C,
2101       // connection_id
2102       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
2103       // packet number
2104       0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
2105       // private flags (entropy)
2106       0x01,
2107
2108       // frame type (ack frame)
2109       // (no nacks, not truncated, 6 byte largest observed, 1 byte delta)
2110       0x4C,
2111       // entropy hash of all received packets.
2112       0xBA,
2113       // largest observed packet number
2114       0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
2115       // Zero delta time.
2116       0x00, 0x00,
2117       // Number of received packets.
2118       0x00,
2119   };
2120   // clang-format on
2121
2122   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2123   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2124
2125   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2126   ASSERT_TRUE(visitor_.header_.get());
2127   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2128
2129   EXPECT_EQ(0u, visitor_.stream_frames_.size());
2130   ASSERT_EQ(1u, visitor_.ack_frames_.size());
2131   QuicAckFrame* frame = visitor_.ack_frames_[0];
2132   EXPECT_EQ(0xBA, frame->entropy_hash);
2133   EXPECT_EQ(UINT64_C(0x0123456789ABF), frame->largest_observed);
2134   ASSERT_TRUE(frame->missing_packets.Empty());
2135
2136   // Verify that the packet re-serializes identically.
2137   QuicFrames frames;
2138   frames.push_back(QuicFrame(frame));
2139   scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
2140   ASSERT_TRUE(data != nullptr);
2141
2142   test::CompareCharArraysWithHexError("constructed packet", data->data(),
2143                                       data->length(), AsChars(packet),
2144                                       arraysize(packet));
2145 }
2146
2147 TEST_P(QuicFramerTest, AckFrame500Nacks) {
2148   // clang-format off
2149   unsigned char packet[] = {
2150       // public flags (8 byte connection_id)
2151       0x3C,
2152       // connection_id
2153       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
2154       // packet number
2155       0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
2156       // private flags (entropy)
2157       0x01,
2158
2159       // frame type (ack frame)
2160       // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
2161       0x6C,
2162       // entropy hash of all received packets.
2163       0xBA,
2164       // largest observed packet number
2165       0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
2166       // Zero delta time.
2167       0x00, 0x00,
2168       // No received packets.
2169       0x00,
2170       // num missing packet ranges
2171       0x02,
2172       // missing packet delta
2173       0x01,
2174       // 243 more missing packets in range.
2175       // The ranges are listed in this order so the re-constructed packet
2176       // matches.
2177       0xF3,
2178       // No gap between ranges
2179       0x00,
2180       // 255 more missing packets in range.
2181       0xFF,
2182       // No revived packets.
2183       0x00,
2184   };
2185   // clang-format on
2186
2187   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2188   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2189
2190   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2191   ASSERT_TRUE(visitor_.header_.get());
2192   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2193
2194   EXPECT_EQ(0u, visitor_.stream_frames_.size());
2195   ASSERT_EQ(1u, visitor_.ack_frames_.size());
2196   QuicAckFrame* frame = visitor_.ack_frames_[0];
2197   EXPECT_EQ(0xBA, frame->entropy_hash);
2198   EXPECT_EQ(UINT64_C(0x0123456789ABF), frame->largest_observed);
2199   EXPECT_EQ(0u, frame->revived_packets.size());
2200   ASSERT_EQ(500u, frame->missing_packets.NumPackets());
2201   EXPECT_EQ(UINT64_C(0x0123456789ABE) - 499, frame->missing_packets.Min());
2202   EXPECT_EQ(UINT64_C(0x0123456789ABE), frame->missing_packets.Max());
2203
2204   // Verify that the packet re-serializes identically.
2205   QuicFrames frames;
2206   frames.push_back(QuicFrame(frame));
2207   scoped_ptr<QuicPacket> data(BuildDataPacket(*visitor_.header_, frames));
2208   ASSERT_TRUE(data != nullptr);
2209
2210   test::CompareCharArraysWithHexError("constructed packet",
2211                                       data->data(), data->length(),
2212                                       AsChars(packet), arraysize(packet));
2213 }
2214
2215 TEST_P(QuicFramerTest, StopWaitingFrame) {
2216   // clang-format off
2217   unsigned char packet[] = {
2218     // public flags (8 byte connection_id)
2219     0x3C,
2220     // connection_id
2221     0x10, 0x32, 0x54, 0x76,
2222     0x98, 0xBA, 0xDC, 0xFE,
2223     // packet number
2224     0xA8, 0x9A, 0x78, 0x56,
2225     0x34, 0x12,
2226     // private flags (entropy)
2227     0x01,
2228
2229     // frame type (ack frame)
2230     // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
2231     0x06,
2232     // entropy hash of sent packets till least awaiting - 1.
2233     0xAB,
2234     // least packet number awaiting an ack, delta from packet number.
2235     0x08, 0x00, 0x00, 0x00,
2236     0x00, 0x00,
2237   };
2238   // clang-format on
2239
2240   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2241   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2242
2243   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2244   ASSERT_TRUE(visitor_.header_.get());
2245   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2246
2247   EXPECT_EQ(0u, visitor_.stream_frames_.size());
2248   ASSERT_EQ(1u, visitor_.stop_waiting_frames_.size());
2249   const QuicStopWaitingFrame& frame = *visitor_.stop_waiting_frames_[0];
2250   EXPECT_EQ(0xAB, frame.entropy_hash);
2251   EXPECT_EQ(UINT64_C(0x0123456789AA0), frame.least_unacked);
2252
2253   const size_t kSentEntropyOffset = kQuicFrameTypeSize;
2254   const size_t kLeastUnackedOffset = kSentEntropyOffset + kQuicEntropyHashSize;
2255   const size_t frame_size = 7;
2256   for (size_t i = kQuicFrameTypeSize; i < frame_size; ++i) {
2257     string expected_error;
2258     if (i < kLeastUnackedOffset) {
2259       expected_error = "Unable to read entropy hash for sent packets.";
2260     } else {
2261       expected_error = "Unable to read least unacked delta.";
2262     }
2263     CheckProcessingFails(
2264         packet,
2265         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
2266                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
2267         expected_error, QUIC_INVALID_STOP_WAITING_DATA);
2268   }
2269 }
2270
2271 TEST_P(QuicFramerTest, RstStreamFrameQuicVersion24) {
2272   if (version_ > QUIC_VERSION_24) {
2273     // QUIC_VERSION_25 removes the error_details field from QuicRstStreamFrame.
2274     return;
2275   }
2276
2277   // clang-format off
2278   unsigned char packet[] = {
2279     // public flags (8 byte connection_id)
2280     0x3C,
2281     // connection_id
2282     0x10, 0x32, 0x54, 0x76,
2283     0x98, 0xBA, 0xDC, 0xFE,
2284     // packet number
2285     0xBC, 0x9A, 0x78, 0x56,
2286     0x34, 0x12,
2287     // private flags
2288     0x00,
2289
2290     // frame type (rst stream frame)
2291     0x01,
2292     // stream id
2293     0x04, 0x03, 0x02, 0x01,
2294
2295     // sent byte offset
2296     0x01, 0x02, 0x03, 0x04,
2297     0x05, 0x06, 0x07, 0x08,
2298
2299     // error code
2300     0x01, 0x00, 0x00, 0x00,
2301
2302     // error details length
2303     0x0d, 0x00,
2304     // error details
2305     'b',  'e',  'c',  'a',
2306     'u',  's',  'e',  ' ',
2307     'I',  ' ',  'c',  'a',
2308     'n',
2309   };
2310   // clang-format on
2311
2312   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2313   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2314
2315   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2316   ASSERT_TRUE(visitor_.header_.get());
2317   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2318
2319   EXPECT_EQ(UINT64_C(0x01020304), visitor_.rst_stream_frame_.stream_id);
2320   EXPECT_EQ(0x01, visitor_.rst_stream_frame_.error_code);
2321   EXPECT_EQ("because I can", visitor_.rst_stream_frame_.error_details);
2322   EXPECT_EQ(UINT64_C(0x0807060504030201),
2323             visitor_.rst_stream_frame_.byte_offset);
2324
2325   // Now test framing boundaries.
2326   for (size_t i = kQuicFrameTypeSize;
2327        i < QuicFramer::GetMinRstStreamFrameSize(); ++i) {
2328     string expected_error;
2329     if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) {
2330       expected_error = "Unable to read stream_id.";
2331     } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
2332                        kQuicMaxStreamOffsetSize) {
2333       expected_error = "Unable to read rst stream sent byte offset.";
2334     } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
2335                        kQuicMaxStreamOffsetSize + kQuicErrorCodeSize) {
2336       expected_error = "Unable to read rst stream error code.";
2337     } else {
2338       expected_error = "Unable to read rst stream error details.";
2339     }
2340     CheckProcessingFails(
2341         packet,
2342         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
2343                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
2344         expected_error, QUIC_INVALID_RST_STREAM_DATA);
2345   }
2346 }
2347
2348 TEST_P(QuicFramerTest, RstStreamFrameQuic) {
2349   if (version_ <= QUIC_VERSION_24) {
2350     // QUIC_VERSION_25 removes the error_details field from QuicRstStreamFrame.
2351     return;
2352   }
2353
2354   // clang-format off
2355   unsigned char packet[] = {
2356     // public flags (8 byte connection_id)
2357     0x3C,
2358     // connection_id
2359     0x10, 0x32, 0x54, 0x76,
2360     0x98, 0xBA, 0xDC, 0xFE,
2361     // packet number
2362     0xBC, 0x9A, 0x78, 0x56,
2363     0x34, 0x12,
2364     // private flags
2365     0x00,
2366
2367     // frame type (rst stream frame)
2368     0x01,
2369     // stream id
2370     0x04, 0x03, 0x02, 0x01,
2371
2372     // sent byte offset
2373     0x01, 0x02, 0x03, 0x04,
2374     0x05, 0x06, 0x07, 0x08,
2375
2376     // error code
2377     0x01, 0x00, 0x00, 0x00,
2378   };
2379   // clang-format on
2380
2381   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2382   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2383
2384   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2385   ASSERT_TRUE(visitor_.header_.get());
2386   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2387
2388   EXPECT_EQ(UINT64_C(0x01020304), visitor_.rst_stream_frame_.stream_id);
2389   EXPECT_EQ(0x01, visitor_.rst_stream_frame_.error_code);
2390   EXPECT_EQ(UINT64_C(0x0807060504030201),
2391             visitor_.rst_stream_frame_.byte_offset);
2392
2393   // Now test framing boundaries.
2394   for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetRstStreamFrameSize();
2395        ++i) {
2396     string expected_error;
2397     if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) {
2398       expected_error = "Unable to read stream_id.";
2399     } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
2400                        kQuicMaxStreamOffsetSize) {
2401       expected_error = "Unable to read rst stream sent byte offset.";
2402     } else if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize +
2403                        kQuicMaxStreamOffsetSize + kQuicErrorCodeSize) {
2404       expected_error = "Unable to read rst stream error code.";
2405     }
2406     CheckProcessingFails(
2407         packet,
2408         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
2409                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
2410         expected_error, QUIC_INVALID_RST_STREAM_DATA);
2411   }
2412 }
2413
2414 TEST_P(QuicFramerTest, ConnectionCloseFrame) {
2415   // clang-format off
2416   unsigned char packet[] = {
2417     // public flags (8 byte connection_id)
2418     0x3C,
2419     // connection_id
2420     0x10, 0x32, 0x54, 0x76,
2421     0x98, 0xBA, 0xDC, 0xFE,
2422     // packet number
2423     0xBC, 0x9A, 0x78, 0x56,
2424     0x34, 0x12,
2425     // private flags
2426     0x00,
2427
2428     // frame type (connection close frame)
2429     0x02,
2430     // error code
2431     0x11, 0x00, 0x00, 0x00,
2432
2433     // error details length
2434     0x0d, 0x00,
2435     // error details
2436     'b',  'e',  'c',  'a',
2437     'u',  's',  'e',  ' ',
2438     'I',  ' ',  'c',  'a',
2439     'n',
2440   };
2441   // clang-format on
2442
2443   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2444   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2445
2446   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2447   ASSERT_TRUE(visitor_.header_.get());
2448   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2449
2450   EXPECT_EQ(0u, visitor_.stream_frames_.size());
2451
2452   EXPECT_EQ(0x11, visitor_.connection_close_frame_.error_code);
2453   EXPECT_EQ("because I can", visitor_.connection_close_frame_.error_details);
2454
2455   ASSERT_EQ(0u, visitor_.ack_frames_.size());
2456
2457   // Now test framing boundaries.
2458   for (size_t i = kQuicFrameTypeSize;
2459        i < QuicFramer::GetMinConnectionCloseFrameSize(); ++i) {
2460     string expected_error;
2461     if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) {
2462       expected_error = "Unable to read connection close error code.";
2463     } else {
2464       expected_error = "Unable to read connection close error details.";
2465     }
2466     CheckProcessingFails(
2467         packet,
2468         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
2469                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
2470         expected_error, QUIC_INVALID_CONNECTION_CLOSE_DATA);
2471   }
2472 }
2473
2474 TEST_P(QuicFramerTest, GoAwayFrame) {
2475   // clang-format off
2476   unsigned char packet[] = {
2477     // public flags (8 byte connection_id)
2478     0x3C,
2479     // connection_id
2480     0x10, 0x32, 0x54, 0x76,
2481     0x98, 0xBA, 0xDC, 0xFE,
2482     // packet number
2483     0xBC, 0x9A, 0x78, 0x56,
2484     0x34, 0x12,
2485     // private flags
2486     0x00,
2487
2488     // frame type (go away frame)
2489     0x03,
2490     // error code
2491     0x09, 0x00, 0x00, 0x00,
2492     // stream id
2493     0x04, 0x03, 0x02, 0x01,
2494     // error details length
2495     0x0d, 0x00,
2496     // error details
2497     'b',  'e',  'c',  'a',
2498     'u',  's',  'e',  ' ',
2499     'I',  ' ',  'c',  'a',
2500     'n',
2501   };
2502   // clang-format on
2503
2504   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2505   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2506
2507   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2508   ASSERT_TRUE(visitor_.header_.get());
2509   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2510
2511   EXPECT_EQ(UINT64_C(0x01020304), visitor_.goaway_frame_.last_good_stream_id);
2512   EXPECT_EQ(0x9, visitor_.goaway_frame_.error_code);
2513   EXPECT_EQ("because I can", visitor_.goaway_frame_.reason_phrase);
2514
2515   const size_t reason_size = arraysize("because I can") - 1;
2516   // Now test framing boundaries.
2517   for (size_t i = kQuicFrameTypeSize;
2518        i < QuicFramer::GetMinGoAwayFrameSize() + reason_size; ++i) {
2519     string expected_error;
2520     if (i < kQuicFrameTypeSize + kQuicErrorCodeSize) {
2521       expected_error = "Unable to read go away error code.";
2522     } else if (i < kQuicFrameTypeSize + kQuicErrorCodeSize +
2523                kQuicMaxStreamIdSize) {
2524       expected_error = "Unable to read last good stream id.";
2525     } else {
2526       expected_error = "Unable to read goaway reason.";
2527     }
2528     CheckProcessingFails(
2529         packet,
2530         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
2531                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
2532         expected_error, QUIC_INVALID_GOAWAY_DATA);
2533   }
2534 }
2535
2536 TEST_P(QuicFramerTest, WindowUpdateFrame) {
2537   // clang-format off
2538   unsigned char packet[] = {
2539     // public flags (8 byte connection_id)
2540     0x3C,
2541     // connection_id
2542     0x10, 0x32, 0x54, 0x76,
2543     0x98, 0xBA, 0xDC, 0xFE,
2544     // packet number
2545     0xBC, 0x9A, 0x78, 0x56,
2546     0x34, 0x12,
2547     // private flags
2548     0x00,
2549
2550     // frame type (window update frame)
2551     0x04,
2552     // stream id
2553     0x04, 0x03, 0x02, 0x01,
2554     // byte offset
2555     0x05, 0x06, 0x07, 0x08,
2556     0x09, 0x0a, 0x0b, 0x0c,
2557   };
2558   // clang-format on
2559
2560   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2561
2562   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2563
2564   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2565   ASSERT_TRUE(visitor_.header_.get());
2566   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2567
2568   EXPECT_EQ(UINT64_C(0x01020304), visitor_.window_update_frame_.stream_id);
2569   EXPECT_EQ(UINT64_C(0x0c0b0a0908070605),
2570             visitor_.window_update_frame_.byte_offset);
2571
2572   // Now test framing boundaries.
2573   for (size_t i = kQuicFrameTypeSize;
2574        i < QuicFramer::GetWindowUpdateFrameSize(); ++i) {
2575     string expected_error;
2576     if (i < kQuicFrameTypeSize + kQuicMaxStreamIdSize) {
2577       expected_error = "Unable to read stream_id.";
2578     } else {
2579       expected_error = "Unable to read window byte_offset.";
2580     }
2581     CheckProcessingFails(
2582         packet,
2583         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
2584                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
2585         expected_error, QUIC_INVALID_WINDOW_UPDATE_DATA);
2586   }
2587 }
2588
2589 TEST_P(QuicFramerTest, BlockedFrame) {
2590   // clang-format off
2591   unsigned char packet[] = {
2592     // public flags (8 byte connection_id)
2593     0x3C,
2594     // connection_id
2595     0x10, 0x32, 0x54, 0x76,
2596     0x98, 0xBA, 0xDC, 0xFE,
2597     // packet number
2598     0xBC, 0x9A, 0x78, 0x56,
2599     0x34, 0x12,
2600     // private flags
2601     0x00,
2602
2603     // frame type (blocked frame)
2604     0x05,
2605     // stream id
2606     0x04, 0x03, 0x02, 0x01,
2607   };
2608   // clang-format on
2609
2610   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2611
2612   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2613
2614   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2615   ASSERT_TRUE(visitor_.header_.get());
2616   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2617
2618   EXPECT_EQ(UINT64_C(0x01020304), visitor_.blocked_frame_.stream_id);
2619
2620   // Now test framing boundaries.
2621   for (size_t i = kQuicFrameTypeSize; i < QuicFramer::GetBlockedFrameSize();
2622        ++i) {
2623     string expected_error = "Unable to read stream_id.";
2624     CheckProcessingFails(
2625         packet,
2626         i + GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
2627                                 PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP),
2628         expected_error, QUIC_INVALID_BLOCKED_DATA);
2629   }
2630 }
2631
2632 TEST_P(QuicFramerTest, PingFrame) {
2633   // clang-format off
2634   unsigned char packet[] = {
2635     // public flags (8 byte connection_id)
2636     0x3C,
2637     // connection_id
2638     0x10, 0x32, 0x54, 0x76,
2639     0x98, 0xBA, 0xDC, 0xFE,
2640     // packet number
2641     0xBC, 0x9A, 0x78, 0x56,
2642     0x34, 0x12,
2643     // private flags
2644     0x00,
2645
2646     // frame type (ping frame)
2647     0x07,
2648   };
2649   // clang-format on
2650
2651   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2652   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2653
2654   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2655   ASSERT_TRUE(visitor_.header_.get());
2656   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2657
2658   EXPECT_EQ(1u, visitor_.ping_frames_.size());
2659
2660   // No need to check the PING frame boundaries because it has no payload.
2661 }
2662
2663 TEST_P(QuicFramerTest, PublicResetPacket) {
2664   // clang-format off
2665   unsigned char packet[] = {
2666     // public flags (public reset, 8 byte connection_id)
2667     0x0E,
2668     // connection_id
2669     0x10, 0x32, 0x54, 0x76,
2670     0x98, 0xBA, 0xDC, 0xFE,
2671     // message tag (kPRST)
2672     'P', 'R', 'S', 'T',
2673     // num_entries (2) + padding
2674     0x02, 0x00, 0x00, 0x00,
2675     // tag kRNON
2676     'R', 'N', 'O', 'N',
2677     // end offset 8
2678     0x08, 0x00, 0x00, 0x00,
2679     // tag kRSEQ
2680     'R', 'S', 'E', 'Q',
2681     // end offset 16
2682     0x10, 0x00, 0x00, 0x00,
2683     // nonce proof
2684     0x89, 0x67, 0x45, 0x23,
2685     0x01, 0xEF, 0xCD, 0xAB,
2686     // rejected packet number
2687     0xBC, 0x9A, 0x78, 0x56,
2688     0x34, 0x12, 0x00, 0x00,
2689   };
2690   // clang-format on
2691
2692   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2693   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2694   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
2695   ASSERT_TRUE(visitor_.public_reset_packet_.get());
2696   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
2697             visitor_.public_reset_packet_->public_header.connection_id);
2698   EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
2699   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
2700   EXPECT_EQ(UINT64_C(0xABCDEF0123456789),
2701             visitor_.public_reset_packet_->nonce_proof);
2702   EXPECT_EQ(UINT64_C(0x123456789ABC),
2703             visitor_.public_reset_packet_->rejected_packet_number);
2704   EXPECT_TRUE(
2705       visitor_.public_reset_packet_->client_address.address().empty());
2706
2707   // Now test framing boundaries.
2708   for (size_t i = 0; i < arraysize(packet); ++i) {
2709     string expected_error;
2710     DVLOG(1) << "iteration: " << i;
2711     if (i < kConnectionIdOffset) {
2712       expected_error = "Unable to read public flags.";
2713       CheckProcessingFails(packet, i, expected_error,
2714                            QUIC_INVALID_PACKET_HEADER);
2715     } else if (i < kPublicResetPacketMessageTagOffset) {
2716       expected_error = "Unable to read ConnectionId.";
2717       CheckProcessingFails(packet, i, expected_error,
2718                            QUIC_INVALID_PACKET_HEADER);
2719     } else {
2720       expected_error = "Unable to read reset message.";
2721       CheckProcessingFails(packet, i, expected_error,
2722                            QUIC_INVALID_PUBLIC_RST_PACKET);
2723     }
2724   }
2725 }
2726
2727 TEST_P(QuicFramerTest, PublicResetPacketWithTrailingJunk) {
2728   // clang-format off
2729   unsigned char packet[] = {
2730     // public flags (public reset, 8 byte connection_id)
2731     0x0E,
2732     // connection_id
2733     0x10, 0x32, 0x54, 0x76,
2734     0x98, 0xBA, 0xDC, 0xFE,
2735     // message tag (kPRST)
2736     'P', 'R', 'S', 'T',
2737     // num_entries (2) + padding
2738     0x02, 0x00, 0x00, 0x00,
2739     // tag kRNON
2740     'R', 'N', 'O', 'N',
2741     // end offset 8
2742     0x08, 0x00, 0x00, 0x00,
2743     // tag kRSEQ
2744     'R', 'S', 'E', 'Q',
2745     // end offset 16
2746     0x10, 0x00, 0x00, 0x00,
2747     // nonce proof
2748     0x89, 0x67, 0x45, 0x23,
2749     0x01, 0xEF, 0xCD, 0xAB,
2750     // rejected packet number
2751     0xBC, 0x9A, 0x78, 0x56,
2752     0x34, 0x12, 0x00, 0x00,
2753     // trailing junk
2754     'j', 'u', 'n', 'k',
2755   };
2756   // clang-format on
2757
2758   string expected_error = "Unable to read reset message.";
2759   CheckProcessingFails(packet, arraysize(packet), expected_error,
2760                        QUIC_INVALID_PUBLIC_RST_PACKET);
2761 }
2762
2763 TEST_P(QuicFramerTest, PublicResetPacketWithClientAddress) {
2764   // clang-format off
2765   unsigned char packet[] = {
2766     // public flags (public reset, 8 byte connection_id)
2767     0x0E,
2768     // connection_id
2769     0x10, 0x32, 0x54, 0x76,
2770     0x98, 0xBA, 0xDC, 0xFE,
2771     // message tag (kPRST)
2772     'P', 'R', 'S', 'T',
2773     // num_entries (3) + padding
2774     0x03, 0x00, 0x00, 0x00,
2775     // tag kRNON
2776     'R', 'N', 'O', 'N',
2777     // end offset 8
2778     0x08, 0x00, 0x00, 0x00,
2779     // tag kRSEQ
2780     'R', 'S', 'E', 'Q',
2781     // end offset 16
2782     0x10, 0x00, 0x00, 0x00,
2783     // tag kCADR
2784     'C', 'A', 'D', 'R',
2785     // end offset 24
2786     0x18, 0x00, 0x00, 0x00,
2787     // nonce proof
2788     0x89, 0x67, 0x45, 0x23,
2789     0x01, 0xEF, 0xCD, 0xAB,
2790     // rejected packet number
2791     0xBC, 0x9A, 0x78, 0x56,
2792     0x34, 0x12, 0x00, 0x00,
2793     // client address: 4.31.198.44:443
2794     0x02, 0x00,
2795     0x04, 0x1F, 0xC6, 0x2C,
2796     0xBB, 0x01,
2797   };
2798   // clang-format on
2799
2800   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2801   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2802   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
2803   ASSERT_TRUE(visitor_.public_reset_packet_.get());
2804   EXPECT_EQ(UINT64_C(0xFEDCBA9876543210),
2805             visitor_.public_reset_packet_->public_header.connection_id);
2806   EXPECT_TRUE(visitor_.public_reset_packet_->public_header.reset_flag);
2807   EXPECT_FALSE(visitor_.public_reset_packet_->public_header.version_flag);
2808   EXPECT_EQ(UINT64_C(0xABCDEF0123456789),
2809             visitor_.public_reset_packet_->nonce_proof);
2810   EXPECT_EQ(UINT64_C(0x123456789ABC),
2811             visitor_.public_reset_packet_->rejected_packet_number);
2812   EXPECT_EQ("4.31.198.44",
2813             IPAddressToString(visitor_.public_reset_packet_->
2814                 client_address.address()));
2815   EXPECT_EQ(443, visitor_.public_reset_packet_->client_address.port());
2816
2817   // Now test framing boundaries.
2818   for (size_t i = 0; i < arraysize(packet); ++i) {
2819     string expected_error;
2820     DVLOG(1) << "iteration: " << i;
2821     if (i < kConnectionIdOffset) {
2822       expected_error = "Unable to read public flags.";
2823       CheckProcessingFails(packet, i, expected_error,
2824                            QUIC_INVALID_PACKET_HEADER);
2825     } else if (i < kPublicResetPacketMessageTagOffset) {
2826       expected_error = "Unable to read ConnectionId.";
2827       CheckProcessingFails(packet, i, expected_error,
2828                            QUIC_INVALID_PACKET_HEADER);
2829     } else {
2830       expected_error = "Unable to read reset message.";
2831       CheckProcessingFails(packet, i, expected_error,
2832                            QUIC_INVALID_PUBLIC_RST_PACKET);
2833     }
2834   }
2835 }
2836
2837 TEST_P(QuicFramerTest, VersionNegotiationPacket) {
2838   // clang-format off
2839   unsigned char packet[] = {
2840     // public flags (version, 8 byte connection_id)
2841     0x3D,
2842     // connection_id
2843     0x10, 0x32, 0x54, 0x76,
2844     0x98, 0xBA, 0xDC, 0xFE,
2845     // version tag
2846     'Q', '0', GetQuicVersionDigitTens(), GetQuicVersionDigitOnes(),
2847     'Q', '2', '.', '0',
2848   };
2849   // clang-format on
2850
2851   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
2852
2853   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2854   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2855   ASSERT_EQ(QUIC_NO_ERROR, framer_.error());
2856   ASSERT_TRUE(visitor_.version_negotiation_packet_.get());
2857   EXPECT_EQ(2u, visitor_.version_negotiation_packet_->versions.size());
2858   EXPECT_EQ(GetParam(), visitor_.version_negotiation_packet_->versions[0]);
2859
2860   for (size_t i = 0; i <= kPublicFlagsSize + PACKET_8BYTE_CONNECTION_ID; ++i) {
2861     string expected_error;
2862     QuicErrorCode error_code = QUIC_INVALID_PACKET_HEADER;
2863     if (i < kConnectionIdOffset) {
2864       expected_error = "Unable to read public flags.";
2865     } else if (i < kVersionOffset) {
2866       expected_error = "Unable to read ConnectionId.";
2867     } else {
2868       expected_error = "Unable to read supported version in negotiation.";
2869       error_code = QUIC_INVALID_VERSION_NEGOTIATION_PACKET;
2870     }
2871     CheckProcessingFails(packet, i, expected_error, error_code);
2872   }
2873 }
2874
2875 TEST_P(QuicFramerTest, FecPacket) {
2876   // clang-format off
2877   unsigned char packet[] = {
2878     // public flags (8 byte connection_id)
2879     0x3C,
2880     // connection_id
2881     0x10, 0x32, 0x54, 0x76,
2882     0x98, 0xBA, 0xDC, 0xFE,
2883     // packet number
2884     0xBC, 0x9A, 0x78, 0x56,
2885     0x34, 0x12,
2886     // private flags (fec group & FEC)
2887     0x06,
2888     // first fec protected packet offset
2889     0x01,
2890
2891     // redundancy
2892     'a',  'b',  'c',  'd',
2893     'e',  'f',  'g',  'h',
2894     'i',  'j',  'k',  'l',
2895     'm',  'n',  'o',  'p',
2896   };
2897   // clang-format on
2898
2899   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
2900   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
2901
2902   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
2903   ASSERT_TRUE(visitor_.header_.get());
2904   EXPECT_TRUE(CheckDecryption(encrypted, !kIncludeVersion));
2905
2906   EXPECT_EQ(0u, visitor_.stream_frames_.size());
2907   EXPECT_EQ(0u, visitor_.ack_frames_.size());
2908   ASSERT_EQ(1, visitor_.fec_count_);
2909   const QuicFecData& fec_data = *visitor_.fec_data_[0];
2910   EXPECT_EQ(UINT64_C(0x0123456789ABB), fec_data.fec_group);
2911   EXPECT_EQ("abcdefghijklmnop", fec_data.redundancy);
2912 }
2913
2914 TEST_P(QuicFramerTest, BuildPaddingFramePacket) {
2915   QuicPacketHeader header;
2916   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
2917   header.public_header.reset_flag = false;
2918   header.public_header.version_flag = false;
2919   header.fec_flag = false;
2920   header.entropy_flag = false;
2921   header.packet_packet_number = UINT64_C(0x123456789ABC);
2922   header.fec_group = 0;
2923
2924   QuicPaddingFrame padding_frame;
2925
2926   QuicFrames frames;
2927   frames.push_back(QuicFrame(&padding_frame));
2928
2929   // clang-format off
2930   unsigned char packet[kMaxPacketSize] = {
2931     // public flags (8 byte connection_id)
2932     0x3C,
2933     // connection_id
2934     0x10, 0x32, 0x54, 0x76,
2935     0x98, 0xBA, 0xDC, 0xFE,
2936     // packet number
2937     0xBC, 0x9A, 0x78, 0x56,
2938     0x34, 0x12,
2939     // private flags
2940     0x00,
2941
2942     // frame type (padding frame)
2943     0x00,
2944     0x00, 0x00, 0x00, 0x00
2945   };
2946   // clang-format on
2947
2948   uint64 header_size =
2949       GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
2950                           PACKET_6BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
2951   memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
2952
2953   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
2954   ASSERT_TRUE(data != nullptr);
2955
2956   test::CompareCharArraysWithHexError("constructed packet",
2957                                       data->data(), data->length(),
2958                                       AsChars(packet),
2959                                       arraysize(packet));
2960 }
2961
2962 TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) {
2963   QuicPacketHeader header;
2964   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
2965   header.public_header.reset_flag = false;
2966   header.public_header.version_flag = false;
2967   header.fec_flag = false;
2968   header.entropy_flag = false;
2969   header.public_header.packet_number_length = PACKET_4BYTE_PACKET_NUMBER;
2970   header.packet_packet_number = UINT64_C(0x123456789ABC);
2971   header.fec_group = 0;
2972
2973   QuicPaddingFrame padding_frame;
2974
2975   QuicFrames frames;
2976   frames.push_back(QuicFrame(&padding_frame));
2977
2978   // clang-format off
2979   unsigned char packet[kMaxPacketSize] = {
2980     // public flags (8 byte connection_id and 4 byte packet number)
2981     0x2C,
2982     // connection_id
2983     0x10, 0x32, 0x54, 0x76,
2984     0x98, 0xBA, 0xDC, 0xFE,
2985     // packet number
2986     0xBC, 0x9A, 0x78, 0x56,
2987     // private flags
2988     0x00,
2989
2990     // frame type (padding frame)
2991     0x00,
2992     0x00, 0x00, 0x00, 0x00
2993   };
2994   // clang-format on
2995
2996   uint64 header_size =
2997       GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
2998                           PACKET_4BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
2999   memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
3000
3001   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3002   ASSERT_TRUE(data != nullptr);
3003
3004   test::CompareCharArraysWithHexError("constructed packet",
3005                                       data->data(), data->length(),
3006                                       AsChars(packet),
3007                                       arraysize(packet));
3008 }
3009
3010 TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) {
3011   QuicPacketHeader header;
3012   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3013   header.public_header.reset_flag = false;
3014   header.public_header.version_flag = false;
3015   header.fec_flag = false;
3016   header.entropy_flag = false;
3017   header.public_header.packet_number_length = PACKET_2BYTE_PACKET_NUMBER;
3018   header.packet_packet_number = UINT64_C(0x123456789ABC);
3019   header.fec_group = 0;
3020
3021   QuicPaddingFrame padding_frame;
3022
3023   QuicFrames frames;
3024   frames.push_back(QuicFrame(&padding_frame));
3025
3026   // clang-format off
3027   unsigned char packet[kMaxPacketSize] = {
3028     // public flags (8 byte connection_id and 2 byte packet number)
3029     0x1C,
3030     // connection_id
3031     0x10, 0x32, 0x54, 0x76,
3032     0x98, 0xBA, 0xDC, 0xFE,
3033     // packet number
3034     0xBC, 0x9A,
3035     // private flags
3036     0x00,
3037
3038     // frame type (padding frame)
3039     0x00,
3040     0x00, 0x00, 0x00, 0x00
3041   };
3042   // clang-format on
3043
3044   uint64 header_size =
3045       GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
3046                           PACKET_2BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
3047   memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
3048
3049   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3050   ASSERT_TRUE(data != nullptr);
3051
3052   test::CompareCharArraysWithHexError("constructed packet",
3053                                       data->data(), data->length(),
3054                                       AsChars(packet),
3055                                       arraysize(packet));
3056 }
3057
3058 TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) {
3059   QuicPacketHeader header;
3060   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3061   header.public_header.reset_flag = false;
3062   header.public_header.version_flag = false;
3063   header.fec_flag = false;
3064   header.entropy_flag = false;
3065   header.public_header.packet_number_length = PACKET_1BYTE_PACKET_NUMBER;
3066   header.packet_packet_number = UINT64_C(0x123456789ABC);
3067   header.fec_group = 0;
3068
3069   QuicPaddingFrame padding_frame;
3070
3071   QuicFrames frames;
3072   frames.push_back(QuicFrame(&padding_frame));
3073
3074   // clang-format off
3075   unsigned char packet[kMaxPacketSize] = {
3076     // public flags (8 byte connection_id and 1 byte packet number)
3077     0x0C,
3078     // connection_id
3079     0x10, 0x32, 0x54, 0x76,
3080     0x98, 0xBA, 0xDC, 0xFE,
3081     // packet number
3082     0xBC,
3083     // private flags
3084     0x00,
3085
3086     // frame type (padding frame)
3087     0x00,
3088     0x00, 0x00, 0x00, 0x00
3089   };
3090   // clang-format on
3091
3092   uint64 header_size =
3093       GetPacketHeaderSize(PACKET_8BYTE_CONNECTION_ID, !kIncludeVersion,
3094                           PACKET_1BYTE_PACKET_NUMBER, NOT_IN_FEC_GROUP);
3095   memset(packet + header_size + 1, 0x00, kMaxPacketSize - header_size - 1);
3096
3097   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3098   ASSERT_TRUE(data != nullptr);
3099
3100   test::CompareCharArraysWithHexError("constructed packet",
3101                                       data->data(), data->length(),
3102                                       AsChars(packet),
3103                                       arraysize(packet));
3104 }
3105
3106 TEST_P(QuicFramerTest, BuildStreamFramePacket) {
3107   QuicPacketHeader header;
3108   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3109   header.public_header.reset_flag = false;
3110   header.public_header.version_flag = false;
3111   header.fec_flag = false;
3112   header.entropy_flag = true;
3113   header.packet_packet_number = UINT64_C(0x77123456789ABC);
3114   header.fec_group = 0;
3115
3116   QuicStreamFrame stream_frame(0x01020304, true, UINT64_C(0xBA98FEDC32107654),
3117                                StringPiece("hello world!"));
3118
3119   QuicFrames frames;
3120   frames.push_back(QuicFrame(&stream_frame));
3121
3122   // clang-format off
3123   unsigned char packet[] = {
3124     // public flags (8 byte connection_id)
3125     0x3C,
3126     // connection_id
3127     0x10, 0x32, 0x54, 0x76,
3128     0x98, 0xBA, 0xDC, 0xFE,
3129     // packet number
3130     0xBC, 0x9A, 0x78, 0x56,
3131     0x34, 0x12,
3132     // private flags (entropy)
3133     0x01,
3134
3135     // frame type (stream frame with fin and no length)
3136     0xDF,
3137     // stream id
3138     0x04, 0x03, 0x02, 0x01,
3139     // offset
3140     0x54, 0x76, 0x10, 0x32,
3141     0xDC, 0xFE, 0x98, 0xBA,
3142     // data
3143     'h',  'e',  'l',  'l',
3144     'o',  ' ',  'w',  'o',
3145     'r',  'l',  'd',  '!',
3146   };
3147   // clang-format on
3148
3149   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3150   ASSERT_TRUE(data != nullptr);
3151
3152   test::CompareCharArraysWithHexError("constructed packet",
3153                                       data->data(), data->length(),
3154                                       AsChars(packet), arraysize(packet));
3155 }
3156
3157 TEST_P(QuicFramerTest, BuildStreamFramePacketInFecGroup) {
3158   QuicPacketHeader header;
3159   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3160   header.public_header.reset_flag = false;
3161   header.public_header.version_flag = false;
3162   header.fec_flag = false;
3163   header.entropy_flag = true;
3164   header.packet_packet_number = UINT64_C(0x77123456789ABC);
3165   header.is_in_fec_group = IN_FEC_GROUP;
3166   header.fec_group = UINT64_C(0x77123456789ABC);
3167
3168   QuicStreamFrame stream_frame(0x01020304, true, UINT64_C(0xBA98FEDC32107654),
3169                                StringPiece("hello world!"));
3170
3171   QuicFrames frames;
3172   frames.push_back(QuicFrame(&stream_frame));
3173   // clang-format off
3174   unsigned char packet[] = {
3175       // public flags (8 byte connection_id)
3176       0x3C,
3177       // connection_id
3178       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
3179       // packet number
3180       0xBC, 0x9A, 0x78, 0x56, 0x34, 0x12,
3181       // private flags (entropy, is_in_fec_group)
3182       0x03,
3183       // FEC group
3184       0x00,
3185       // frame type (stream frame with fin and data length field)
3186       0xFF,
3187       // stream id
3188       0x04, 0x03, 0x02, 0x01,
3189       // offset
3190       0x54, 0x76, 0x10, 0x32, 0xDC, 0xFE, 0x98, 0xBA,
3191       // data length (since packet is in an FEC group)
3192       0x0C, 0x00,
3193       // data
3194       'h',  'e',  'l',  'l',  'o',  ' ',  'w',  'o',  'r', 'l', 'd', '!',
3195   };
3196   // clang-format on
3197
3198   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3199   ASSERT_TRUE(data != nullptr);
3200
3201   test::CompareCharArraysWithHexError("constructed packet",
3202                                       data->data(), data->length(),
3203                                       AsChars(packet), arraysize(packet));
3204 }
3205
3206 TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) {
3207   QuicPacketHeader header;
3208   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3209   header.public_header.reset_flag = false;
3210   header.public_header.version_flag = true;
3211   header.fec_flag = false;
3212   header.entropy_flag = true;
3213   header.packet_packet_number = UINT64_C(0x77123456789ABC);
3214   header.fec_group = 0;
3215
3216   QuicStreamFrame stream_frame(0x01020304, true, UINT64_C(0xBA98FEDC32107654),
3217                                StringPiece("hello world!"));
3218
3219   QuicFrames frames;
3220   frames.push_back(QuicFrame(&stream_frame));
3221
3222   // clang-format off
3223   unsigned char packet[] = {
3224       // public flags (version, 8 byte connection_id)
3225       0x3D,
3226       // connection_id
3227       0x10,
3228       0x32,
3229       0x54,
3230       0x76,
3231       0x98,
3232       0xBA,
3233       0xDC,
3234       0xFE,
3235       // version tag
3236       'Q',
3237       '0',
3238       GetQuicVersionDigitTens(),
3239       GetQuicVersionDigitOnes(),
3240       // packet number
3241       0xBC,
3242       0x9A,
3243       0x78,
3244       0x56,
3245       0x34,
3246       0x12,
3247       // private flags (entropy)
3248       0x01,
3249
3250       // frame type (stream frame with fin and no length)
3251       0xDF,
3252       // stream id
3253       0x04,
3254       0x03,
3255       0x02,
3256       0x01,
3257       // offset
3258       0x54,
3259       0x76,
3260       0x10,
3261       0x32,
3262       0xDC,
3263       0xFE,
3264       0x98,
3265       0xBA,
3266       // data
3267       'h',
3268       'e',
3269       'l',
3270       'l',
3271       'o',
3272       ' ',
3273       'w',
3274       'o',
3275       'r',
3276       'l',
3277       'd',
3278       '!',
3279   };
3280   // clang-format on
3281
3282   QuicFramerPeer::SetPerspective(&framer_, Perspective::IS_CLIENT);
3283   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3284   ASSERT_TRUE(data != nullptr);
3285
3286   test::CompareCharArraysWithHexError("constructed packet",
3287                                       data->data(), data->length(),
3288                                       AsChars(packet), arraysize(packet));
3289 }
3290
3291 TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) {
3292   QuicPacketPublicHeader header;
3293   header.connection_id = UINT64_C(0xFEDCBA9876543210);
3294   header.reset_flag = false;
3295   header.version_flag = true;
3296
3297   // clang-format off
3298   unsigned char packet[] = {
3299       // public flags (version, 8 byte connection_id)
3300       0x0D,
3301       // connection_id
3302       0x10,
3303       0x32,
3304       0x54,
3305       0x76,
3306       0x98,
3307       0xBA,
3308       0xDC,
3309       0xFE,
3310       // version tag
3311       'Q',
3312       '0',
3313       GetQuicVersionDigitTens(),
3314       GetQuicVersionDigitOnes(),
3315   };
3316   // clang-format on
3317
3318   QuicVersionVector versions;
3319   versions.push_back(GetParam());
3320   scoped_ptr<QuicEncryptedPacket> data(
3321       framer_.BuildVersionNegotiationPacket(header, versions));
3322
3323   test::CompareCharArraysWithHexError("constructed packet", data->data(),
3324                                       data->length(), AsChars(packet),
3325                                       arraysize(packet));
3326 }
3327
3328 TEST_P(QuicFramerTest, BuildAckFramePacket) {
3329   QuicPacketHeader header;
3330   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3331   header.public_header.reset_flag = false;
3332   header.public_header.version_flag = false;
3333   header.fec_flag = false;
3334   header.entropy_flag = true;
3335   header.packet_packet_number = UINT64_C(0x770123456789AA8);
3336   header.fec_group = 0;
3337
3338   QuicAckFrame ack_frame;
3339   ack_frame.entropy_hash = 0x43;
3340   ack_frame.largest_observed = UINT64_C(0x770123456789ABF);
3341   ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
3342   ack_frame.missing_packets.Add(UINT64_C(0x770123456789ABE));
3343
3344   QuicFrames frames;
3345   frames.push_back(QuicFrame(&ack_frame));
3346
3347   // clang-format off
3348   unsigned char packet[] = {
3349       // public flags (8 byte connection_id)
3350       0x3C,
3351       // connection_id
3352       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
3353       // packet number
3354       0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
3355       // private flags (entropy)
3356       0x01,
3357
3358       // frame type (ack frame)
3359       // (has nacks, not truncated, 6 byte largest observed, 1 byte delta)
3360       0x6C,
3361       // entropy hash of all received packets.
3362       0x43,
3363       // largest observed packet number
3364       0xBF, 0x9A, 0x78, 0x56, 0x34, 0x12,
3365       // Zero delta time.
3366       0x00, 0x00,
3367       // num received packets.
3368       0x00,
3369       // num missing packet ranges
3370       0x01,
3371       // missing packet delta
3372       0x01,
3373       // 0 more missing packets in range.
3374       0x00,
3375       // 0 revived packets.
3376       0x00,
3377   };
3378   // clang-format on
3379
3380   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3381   ASSERT_TRUE(data != nullptr);
3382
3383   test::CompareCharArraysWithHexError("constructed packet",
3384                                       data->data(), data->length(),
3385                                       AsChars(packet), arraysize(packet));
3386 }
3387
3388 // TODO(jri): Add test for tuncated packets in which the original ack frame had
3389 // revived packets. (In both the large and small packet cases below).
3390
3391 TEST_P(QuicFramerTest, BuildTruncatedAckFrameLargePacket) {
3392   QuicPacketHeader header;
3393   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3394   header.public_header.reset_flag = false;
3395   header.public_header.version_flag = false;
3396   header.fec_flag = false;
3397   header.entropy_flag = true;
3398   header.packet_packet_number = UINT64_C(0x770123456789AA8);
3399   header.fec_group = 0;
3400
3401   QuicAckFrame ack_frame;
3402   // This entropy hash is different from what shows up in the packet below,
3403   // since entropy is recomputed by the framer on ack truncation (by
3404   // TestEntropyCalculator for this test.)
3405   ack_frame.entropy_hash = 0x43;
3406   ack_frame.largest_observed = 2 * 300;
3407   ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
3408   for (size_t i = 1; i < 2 * 300; i += 2) {
3409     ack_frame.missing_packets.Add(i);
3410   }
3411
3412   QuicFrames frames;
3413   frames.push_back(QuicFrame(&ack_frame));
3414
3415   // clang-format off
3416   unsigned char packet[] = {
3417       // public flags (8 byte connection_id)
3418       0x3C,
3419       // connection_id
3420       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
3421       // packet number
3422       0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
3423       // private flags (entropy)
3424       0x01,
3425
3426       // frame type (ack frame)
3427       // (has nacks, is truncated, 2 byte largest observed, 1 byte delta)
3428       0x74,
3429       // entropy hash of all received packets, set to 1 by TestEntropyCalculator
3430       // since ack is truncated.
3431       0x01,
3432       // 2-byte largest observed packet number.
3433       // Expected to be 510 (0x1FE), since only 255 nack ranges can fit.
3434       0xFE, 0x01,
3435       // Zero delta time.
3436       0x00, 0x00,
3437       // num missing packet ranges (limited to 255 by size of this field).
3438       0xFF,
3439       // {missing packet delta, further missing packets in range}
3440       // 6 nack ranges x 42 + 3 nack ranges
3441       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3442       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3443       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3444       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3445       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3446       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3447       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3448       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3449       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3450       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3451
3452       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3453       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3454       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3455       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3456       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3457       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3458       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3459       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3460       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3461       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3462
3463       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3464       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3465       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3466       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3467       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3468       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3469       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3470       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3471       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3472       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3473
3474       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3475       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3476       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3477       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3478       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3479       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3480       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3481       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3482       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3483       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3484
3485       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3486       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3487       0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3488
3489       // 0 revived packets.
3490       0x00,
3491   };
3492   // clang-format on
3493
3494   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3495   ASSERT_TRUE(data != nullptr);
3496
3497   test::CompareCharArraysWithHexError("constructed packet",
3498                                       data->data(), data->length(),
3499                                       AsChars(packet), arraysize(packet));
3500 }
3501
3502 TEST_P(QuicFramerTest, BuildTruncatedAckFrameSmallPacket) {
3503   QuicPacketHeader header;
3504   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3505   header.public_header.reset_flag = false;
3506   header.public_header.version_flag = false;
3507   header.fec_flag = false;
3508   header.entropy_flag = true;
3509   header.packet_packet_number = UINT64_C(0x770123456789AA8);
3510   header.fec_group = 0;
3511
3512   QuicAckFrame ack_frame;
3513   // This entropy hash is different from what shows up in the packet below,
3514   // since entropy is recomputed by the framer on ack truncation (by
3515   // TestEntropyCalculator for this test.)
3516   ack_frame.entropy_hash = 0x43;
3517   ack_frame.largest_observed = 2 * 300;
3518   ack_frame.delta_time_largest_observed = QuicTime::Delta::Zero();
3519   for (size_t i = 1; i < 2 * 300; i += 2) {
3520     ack_frame.missing_packets.Add(i);
3521   }
3522
3523   QuicFrames frames;
3524   frames.push_back(QuicFrame(&ack_frame));
3525
3526   // clang-format off
3527   unsigned char packet[] = {
3528       // public flags (8 byte connection_id)
3529       0x3C,
3530       // connection_id
3531       0x10, 0x32, 0x54, 0x76, 0x98, 0xBA, 0xDC, 0xFE,
3532       // packet number
3533       0xA8, 0x9A, 0x78, 0x56, 0x34, 0x12,
3534       // private flags (entropy)
3535       0x01,
3536
3537       // frame type (ack frame)
3538       // (has nacks, is truncated, 2 byte largest observed, 1 byte delta)
3539       0x74,
3540       // entropy hash of all received packets, set to 1 by TestEntropyCalculator
3541       // since ack is truncated.
3542       0x01,
3543       // 2-byte largest observed packet number.
3544       // Expected to be 12 (0x0C), since only 6 nack ranges can fit.
3545       0x0C, 0x00,
3546       // Zero delta time.
3547       0x00, 0x00,
3548       // num missing packet ranges (limited to 6 by packet size of 37).
3549       0x06,
3550       // {missing packet delta, further missing packets in range}
3551       // 6 nack ranges
3552       0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00, 0x01, 0x00,
3553       // 0 revived packets.
3554       0x00,
3555   };
3556   // clang-format on
3557
3558   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames, 37u));
3559   ASSERT_TRUE(data != nullptr);
3560   // Expect 1 byte unused since at least 2 bytes are needed to fit more nacks.
3561   EXPECT_EQ(36u, data->length());
3562   test::CompareCharArraysWithHexError("constructed packet",
3563                                       data->data(), data->length(),
3564                                       AsChars(packet), arraysize(packet));
3565 }
3566
3567 TEST_P(QuicFramerTest, BuildStopWaitingPacket) {
3568   QuicPacketHeader header;
3569   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3570   header.public_header.reset_flag = false;
3571   header.public_header.version_flag = false;
3572   header.fec_flag = false;
3573   header.entropy_flag = true;
3574   header.packet_packet_number = UINT64_C(0x770123456789AA8);
3575   header.fec_group = 0;
3576
3577   QuicStopWaitingFrame stop_waiting_frame;
3578   stop_waiting_frame.entropy_hash = 0x14;
3579   stop_waiting_frame.least_unacked = UINT64_C(0x770123456789AA0);
3580
3581   QuicFrames frames;
3582   frames.push_back(QuicFrame(&stop_waiting_frame));
3583
3584   // clang-format off
3585   unsigned char packet[] = {
3586     // public flags (8 byte connection_id)
3587     0x3C,
3588     // connection_id
3589     0x10, 0x32, 0x54, 0x76,
3590     0x98, 0xBA, 0xDC, 0xFE,
3591     // packet number
3592     0xA8, 0x9A, 0x78, 0x56,
3593     0x34, 0x12,
3594     // private flags (entropy)
3595     0x01,
3596
3597     // frame type (stop waiting frame)
3598     0x06,
3599     // entropy hash of sent packets till least awaiting - 1.
3600     0x14,
3601     // least packet number awaiting an ack, delta from packet number.
3602     0x08, 0x00, 0x00, 0x00,
3603     0x00, 0x00,
3604   };
3605   // clang-format on
3606
3607   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3608   ASSERT_TRUE(data != nullptr);
3609
3610   test::CompareCharArraysWithHexError("constructed packet",
3611                                       data->data(), data->length(),
3612                                       AsChars(packet), arraysize(packet));
3613 }
3614
3615 TEST_P(QuicFramerTest, BuildRstFramePacketQuicVersion24) {
3616   if (version_ > QUIC_VERSION_24) {
3617     // QUIC_VERSION_25 removes the error_details field from QuicRstStreamFrame.
3618     return;
3619   }
3620
3621   QuicPacketHeader header;
3622   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3623   header.public_header.reset_flag = false;
3624   header.public_header.version_flag = false;
3625   header.fec_flag = false;
3626   header.entropy_flag = false;
3627   header.packet_packet_number = UINT64_C(0x123456789ABC);
3628   header.fec_group = 0;
3629
3630   QuicRstStreamFrame rst_frame;
3631   rst_frame.stream_id = 0x01020304;
3632   rst_frame.error_code = static_cast<QuicRstStreamErrorCode>(0x05060708);
3633   rst_frame.error_details = "because I can";
3634   rst_frame.byte_offset = 0x0807060504030201;
3635
3636   // clang-format off
3637   unsigned char packet[] = {
3638     // public flags (8 byte connection_id)
3639     0x3C,
3640     // connection_id
3641     0x10, 0x32, 0x54, 0x76,
3642     0x98, 0xBA, 0xDC, 0xFE,
3643     // packet number
3644     0xBC, 0x9A, 0x78, 0x56,
3645     0x34, 0x12,
3646     // private flags
3647     0x00,
3648
3649     // frame type (rst stream frame)
3650     0x01,
3651     // stream id
3652     0x04, 0x03, 0x02, 0x01,
3653     // sent byte offset
3654     0x01, 0x02, 0x03, 0x04,
3655     0x05, 0x06, 0x07, 0x08,
3656     // error code
3657     0x08, 0x07, 0x06, 0x05,
3658     // error details length
3659     0x0d, 0x00,
3660     // error details
3661     'b',  'e',  'c',  'a',
3662     'u',  's',  'e',  ' ',
3663     'I',  ' ',  'c',  'a',
3664     'n',
3665   };
3666   // clang-format on
3667
3668   QuicFrames frames;
3669   frames.push_back(QuicFrame(&rst_frame));
3670
3671   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3672   ASSERT_TRUE(data != nullptr);
3673
3674   test::CompareCharArraysWithHexError("constructed packet", data->data(),
3675                                       data->length(), AsChars(packet),
3676                                       arraysize(packet));
3677 }
3678
3679 TEST_P(QuicFramerTest, BuildRstFramePacketQuic) {
3680   if (version_ <= QUIC_VERSION_24) {
3681     // QUIC_VERSION_25 removes the error_details field from QuicRstStreamFrame.
3682     return;
3683   }
3684
3685   QuicPacketHeader header;
3686   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3687   header.public_header.reset_flag = false;
3688   header.public_header.version_flag = false;
3689   header.fec_flag = false;
3690   header.entropy_flag = false;
3691   header.packet_packet_number = UINT64_C(0x123456789ABC);
3692   header.fec_group = 0;
3693
3694   QuicRstStreamFrame rst_frame;
3695   rst_frame.stream_id = 0x01020304;
3696   rst_frame.error_code = static_cast<QuicRstStreamErrorCode>(0x05060708);
3697   rst_frame.byte_offset = 0x0807060504030201;
3698
3699   // clang-format off
3700   unsigned char packet[] = {
3701     // public flags (8 byte connection_id)
3702     0x3C,
3703     // connection_id
3704     0x10, 0x32, 0x54, 0x76,
3705     0x98, 0xBA, 0xDC, 0xFE,
3706     // packet number
3707     0xBC, 0x9A, 0x78, 0x56,
3708     0x34, 0x12,
3709     // private flags
3710     0x00,
3711
3712     // frame type (rst stream frame)
3713     0x01,
3714     // stream id
3715     0x04, 0x03, 0x02, 0x01,
3716     // sent byte offset
3717     0x01, 0x02, 0x03, 0x04,
3718     0x05, 0x06, 0x07, 0x08,
3719     // error code
3720     0x08, 0x07, 0x06, 0x05,
3721   };
3722   // clang-format on
3723
3724   QuicFrames frames;
3725   frames.push_back(QuicFrame(&rst_frame));
3726
3727   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3728   ASSERT_TRUE(data != nullptr);
3729
3730   test::CompareCharArraysWithHexError("constructed packet", data->data(),
3731                                       data->length(), AsChars(packet),
3732                                       arraysize(packet));
3733 }
3734
3735 TEST_P(QuicFramerTest, BuildCloseFramePacket) {
3736   QuicPacketHeader header;
3737   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3738   header.public_header.reset_flag = false;
3739   header.public_header.version_flag = false;
3740   header.fec_flag = false;
3741   header.entropy_flag = true;
3742   header.packet_packet_number = UINT64_C(0x123456789ABC);
3743   header.fec_group = 0;
3744
3745   QuicConnectionCloseFrame close_frame;
3746   close_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
3747   close_frame.error_details = "because I can";
3748
3749   QuicFrames frames;
3750   frames.push_back(QuicFrame(&close_frame));
3751
3752   // clang-format off
3753   unsigned char packet[] = {
3754     // public flags (8 byte connection_id)
3755     0x3C,
3756     // connection_id
3757     0x10, 0x32, 0x54, 0x76,
3758     0x98, 0xBA, 0xDC, 0xFE,
3759     // packet number
3760     0xBC, 0x9A, 0x78, 0x56,
3761     0x34, 0x12,
3762     // private flags (entropy)
3763     0x01,
3764
3765     // frame type (connection close frame)
3766     0x02,
3767     // error code
3768     0x08, 0x07, 0x06, 0x05,
3769     // error details length
3770     0x0d, 0x00,
3771     // error details
3772     'b',  'e',  'c',  'a',
3773     'u',  's',  'e',  ' ',
3774     'I',  ' ',  'c',  'a',
3775     'n',
3776   };
3777   // clang-format on
3778
3779   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3780   ASSERT_TRUE(data != nullptr);
3781
3782   test::CompareCharArraysWithHexError("constructed packet",
3783                                       data->data(), data->length(),
3784                                       AsChars(packet), arraysize(packet));
3785 }
3786
3787 TEST_P(QuicFramerTest, BuildGoAwayPacket) {
3788   QuicPacketHeader header;
3789   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3790   header.public_header.reset_flag = false;
3791   header.public_header.version_flag = false;
3792   header.fec_flag = false;
3793   header.entropy_flag = true;
3794   header.packet_packet_number = UINT64_C(0x123456789ABC);
3795   header.fec_group = 0;
3796
3797   QuicGoAwayFrame goaway_frame;
3798   goaway_frame.error_code = static_cast<QuicErrorCode>(0x05060708);
3799   goaway_frame.last_good_stream_id = 0x01020304;
3800   goaway_frame.reason_phrase = "because I can";
3801
3802   QuicFrames frames;
3803   frames.push_back(QuicFrame(&goaway_frame));
3804
3805   // clang-format off
3806   unsigned char packet[] = {
3807     // public flags (8 byte connection_id)
3808     0x3C,
3809     // connection_id
3810     0x10, 0x32, 0x54, 0x76,
3811     0x98, 0xBA, 0xDC, 0xFE,
3812     // packet number
3813     0xBC, 0x9A, 0x78, 0x56,
3814     0x34, 0x12,
3815     // private flags(entropy)
3816     0x01,
3817
3818     // frame type (go away frame)
3819     0x03,
3820     // error code
3821     0x08, 0x07, 0x06, 0x05,
3822     // stream id
3823     0x04, 0x03, 0x02, 0x01,
3824     // error details length
3825     0x0d, 0x00,
3826     // error details
3827     'b',  'e',  'c',  'a',
3828     'u',  's',  'e',  ' ',
3829     'I',  ' ',  'c',  'a',
3830     'n',
3831   };
3832   // clang-format on
3833
3834   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3835   ASSERT_TRUE(data != nullptr);
3836
3837   test::CompareCharArraysWithHexError("constructed packet",
3838                                       data->data(), data->length(),
3839                                       AsChars(packet), arraysize(packet));
3840 }
3841
3842 TEST_P(QuicFramerTest, BuildWindowUpdatePacket) {
3843   QuicPacketHeader header;
3844   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3845   header.public_header.reset_flag = false;
3846   header.public_header.version_flag = false;
3847   header.fec_flag = false;
3848   header.entropy_flag = true;
3849   header.packet_packet_number = UINT64_C(0x123456789ABC);
3850   header.fec_group = 0;
3851
3852   QuicWindowUpdateFrame window_update_frame;
3853   window_update_frame.stream_id = 0x01020304;
3854   window_update_frame.byte_offset = 0x1122334455667788;
3855
3856   QuicFrames frames;
3857   frames.push_back(QuicFrame(&window_update_frame));
3858
3859   // clang-format off
3860   unsigned char packet[] = {
3861     // public flags (8 byte connection_id)
3862     0x3C,
3863     // connection_id
3864     0x10, 0x32, 0x54, 0x76,
3865     0x98, 0xBA, 0xDC, 0xFE,
3866     // packet number
3867     0xBC, 0x9A, 0x78, 0x56,
3868     0x34, 0x12,
3869     // private flags(entropy)
3870     0x01,
3871
3872     // frame type (window update frame)
3873     0x04,
3874     // stream id
3875     0x04, 0x03, 0x02, 0x01,
3876     // byte offset
3877     0x88, 0x77, 0x66, 0x55,
3878     0x44, 0x33, 0x22, 0x11,
3879   };
3880   // clang-format on
3881
3882   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3883   ASSERT_TRUE(data != nullptr);
3884
3885   test::CompareCharArraysWithHexError("constructed packet", data->data(),
3886                                       data->length(), AsChars(packet),
3887                                       arraysize(packet));
3888 }
3889
3890 TEST_P(QuicFramerTest, BuildBlockedPacket) {
3891   QuicPacketHeader header;
3892   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3893   header.public_header.reset_flag = false;
3894   header.public_header.version_flag = false;
3895   header.fec_flag = false;
3896   header.entropy_flag = true;
3897   header.packet_packet_number = UINT64_C(0x123456789ABC);
3898   header.fec_group = 0;
3899
3900   QuicBlockedFrame blocked_frame;
3901   blocked_frame.stream_id = 0x01020304;
3902
3903   QuicFrames frames;
3904   frames.push_back(QuicFrame(&blocked_frame));
3905
3906   // clang-format off
3907   unsigned char packet[] = {
3908     // public flags (8 byte connection_id)
3909     0x3C,
3910     // connection_id
3911     0x10, 0x32, 0x54, 0x76,
3912     0x98, 0xBA, 0xDC, 0xFE,
3913     // packet number
3914     0xBC, 0x9A, 0x78, 0x56,
3915     0x34, 0x12,
3916     // private flags(entropy)
3917     0x01,
3918
3919     // frame type (blocked frame)
3920     0x05,
3921     // stream id
3922     0x04, 0x03, 0x02, 0x01,
3923   };
3924   // clang-format on
3925
3926   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3927   ASSERT_TRUE(data != nullptr);
3928
3929   test::CompareCharArraysWithHexError("constructed packet", data->data(),
3930                                       data->length(), AsChars(packet),
3931                                       arraysize(packet));
3932 }
3933
3934 TEST_P(QuicFramerTest, BuildPingPacket) {
3935   QuicPacketHeader header;
3936   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3937   header.public_header.reset_flag = false;
3938   header.public_header.version_flag = false;
3939   header.fec_flag = false;
3940   header.entropy_flag = true;
3941   header.packet_packet_number = UINT64_C(0x123456789ABC);
3942   header.fec_group = 0;
3943
3944   QuicPingFrame ping_frame;
3945
3946   QuicFrames frames;
3947   frames.push_back(QuicFrame(&ping_frame));
3948
3949   // clang-format off
3950   unsigned char packet[] = {
3951     // public flags (8 byte connection_id)
3952     0x3C,
3953     // connection_id
3954     0x10, 0x32, 0x54, 0x76,
3955     0x98, 0xBA, 0xDC, 0xFE,
3956     // packet number
3957     0xBC, 0x9A, 0x78, 0x56,
3958     0x34, 0x12,
3959     // private flags(entropy)
3960     0x01,
3961
3962     // frame type (ping frame)
3963     0x07,
3964   };
3965   // clang-format on
3966
3967   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
3968   ASSERT_TRUE(data != nullptr);
3969
3970   test::CompareCharArraysWithHexError("constructed packet", data->data(),
3971                                       data->length(), AsChars(packet),
3972                                       arraysize(packet));
3973 }
3974
3975 // Test that the MTU discovery packet is serialized correctly as a PING packet.
3976 TEST_P(QuicFramerTest, BuildMtuDiscoveryPacket) {
3977   QuicPacketHeader header;
3978   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
3979   header.public_header.reset_flag = false;
3980   header.public_header.version_flag = false;
3981   header.fec_flag = false;
3982   header.entropy_flag = true;
3983   header.packet_packet_number = UINT64_C(0x123456789ABC);
3984   header.fec_group = 0;
3985
3986   QuicMtuDiscoveryFrame mtu_discovery_frame;
3987
3988   QuicFrames frames;
3989   frames.push_back(QuicFrame(&mtu_discovery_frame));
3990
3991   // clang-format off
3992   unsigned char packet[] = {
3993     // public flags (8 byte connection_id)
3994     0x3C,
3995     // connection_id
3996     0x10, 0x32, 0x54, 0x76,
3997     0x98, 0xBA, 0xDC, 0xFE,
3998     // packet number
3999     0xBC, 0x9A, 0x78, 0x56,
4000     0x34, 0x12,
4001     // private flags(entropy)
4002     0x01,
4003
4004     // frame type (ping frame)
4005     0x07,
4006   };
4007   // clang-format on
4008
4009   scoped_ptr<QuicPacket> data(BuildDataPacket(header, frames));
4010   ASSERT_TRUE(data != nullptr);
4011
4012   test::CompareCharArraysWithHexError("constructed packet", data->data(),
4013                                       data->length(), AsChars(packet),
4014                                       arraysize(packet));
4015 }
4016
4017 TEST_P(QuicFramerTest, BuildPublicResetPacket) {
4018   QuicPublicResetPacket reset_packet;
4019   reset_packet.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
4020   reset_packet.public_header.reset_flag = true;
4021   reset_packet.public_header.version_flag = false;
4022   reset_packet.rejected_packet_number = UINT64_C(0x123456789ABC);
4023   reset_packet.nonce_proof = UINT64_C(0xABCDEF0123456789);
4024
4025   // clang-format off
4026   unsigned char packet[] = {
4027     // public flags (public reset, 8 byte ConnectionId)
4028     0x0E,
4029     // connection_id
4030     0x10, 0x32, 0x54, 0x76,
4031     0x98, 0xBA, 0xDC, 0xFE,
4032     // message tag (kPRST)
4033     'P', 'R', 'S', 'T',
4034     // num_entries (2) + padding
4035     0x02, 0x00, 0x00, 0x00,
4036     // tag kRNON
4037     'R', 'N', 'O', 'N',
4038     // end offset 8
4039     0x08, 0x00, 0x00, 0x00,
4040     // tag kRSEQ
4041     'R', 'S', 'E', 'Q',
4042     // end offset 16
4043     0x10, 0x00, 0x00, 0x00,
4044     // nonce proof
4045     0x89, 0x67, 0x45, 0x23,
4046     0x01, 0xEF, 0xCD, 0xAB,
4047     // rejected packet number
4048     0xBC, 0x9A, 0x78, 0x56,
4049     0x34, 0x12, 0x00, 0x00,
4050   };
4051   // clang-format on
4052
4053   scoped_ptr<QuicEncryptedPacket> data(
4054       framer_.BuildPublicResetPacket(reset_packet));
4055   ASSERT_TRUE(data != nullptr);
4056
4057   test::CompareCharArraysWithHexError("constructed packet",
4058                                       data->data(), data->length(),
4059                                       AsChars(packet), arraysize(packet));
4060 }
4061
4062 TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) {
4063   QuicPublicResetPacket reset_packet;
4064   reset_packet.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
4065   reset_packet.public_header.reset_flag = true;
4066   reset_packet.public_header.version_flag = false;
4067   reset_packet.rejected_packet_number = UINT64_C(0x123456789ABC);
4068   reset_packet.nonce_proof = UINT64_C(0xABCDEF0123456789);
4069   reset_packet.client_address = IPEndPoint(Loopback4(), 0x1234);
4070
4071   // clang-format off
4072   unsigned char packet[] = {
4073     // public flags (public reset, 8 byte ConnectionId)
4074     0x0E,
4075     // connection_id
4076     0x10, 0x32, 0x54, 0x76,
4077     0x98, 0xBA, 0xDC, 0xFE,
4078     // message tag (kPRST)
4079     'P', 'R', 'S', 'T',
4080     // num_entries (3) + padding
4081     0x03, 0x00, 0x00, 0x00,
4082     // tag kRNON
4083     'R', 'N', 'O', 'N',
4084     // end offset 8
4085     0x08, 0x00, 0x00, 0x00,
4086     // tag kRSEQ
4087     'R', 'S', 'E', 'Q',
4088     // end offset 16
4089     0x10, 0x00, 0x00, 0x00,
4090     // tag kCADR
4091     'C', 'A', 'D', 'R',
4092     // end offset 24
4093     0x18, 0x00, 0x00, 0x00,
4094     // nonce proof
4095     0x89, 0x67, 0x45, 0x23,
4096     0x01, 0xEF, 0xCD, 0xAB,
4097     // rejected packet number
4098     0xBC, 0x9A, 0x78, 0x56,
4099     0x34, 0x12, 0x00, 0x00,
4100     // client address
4101     0x02, 0x00,
4102     0x7F, 0x00, 0x00, 0x01,
4103     0x34, 0x12,
4104   };
4105   // clang-format on
4106
4107   scoped_ptr<QuicEncryptedPacket> data(
4108       framer_.BuildPublicResetPacket(reset_packet));
4109   ASSERT_TRUE(data != nullptr);
4110
4111   test::CompareCharArraysWithHexError("constructed packet",
4112                                       data->data(), data->length(),
4113                                       AsChars(packet), arraysize(packet));
4114 }
4115
4116 TEST_P(QuicFramerTest, BuildFecPacket) {
4117   QuicPacketHeader header;
4118   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
4119   header.public_header.reset_flag = false;
4120   header.public_header.version_flag = false;
4121   header.fec_flag = true;
4122   header.entropy_flag = true;
4123   header.packet_packet_number = (UINT64_C(0x123456789ABC));
4124   header.is_in_fec_group = IN_FEC_GROUP;
4125   header.fec_group = UINT64_C(0x123456789ABB);
4126
4127   QuicFecData fec_data;
4128   fec_data.fec_group = 1;
4129   fec_data.redundancy = "abcdefghijklmnop";
4130
4131   // clang-format off
4132   unsigned char packet[] = {
4133     // public flags (8 byte connection_id)
4134     0x3C,
4135     // connection_id
4136     0x10, 0x32, 0x54, 0x76,
4137     0x98, 0xBA, 0xDC, 0xFE,
4138     // packet number
4139     0xBC, 0x9A, 0x78, 0x56,
4140     0x34, 0x12,
4141     // private flags (entropy & fec group & fec packet)
4142     0x07,
4143     // first fec protected packet offset
4144     0x01,
4145
4146     // redundancy
4147     'a',  'b',  'c',  'd',
4148     'e',  'f',  'g',  'h',
4149     'i',  'j',  'k',  'l',
4150     'm',  'n',  'o',  'p',
4151   };
4152   // clang-format on
4153
4154   scoped_ptr<QuicPacket> data(framer_.BuildFecPacket(header, fec_data));
4155   ASSERT_TRUE(data != nullptr);
4156
4157   test::CompareCharArraysWithHexError("constructed packet",
4158                                       data->data(), data->length(),
4159                                       AsChars(packet), arraysize(packet));
4160 }
4161
4162 TEST_P(QuicFramerTest, EncryptPacket) {
4163   QuicPacketNumber packet_number = UINT64_C(0x123456789ABC);
4164   // clang-format off
4165   unsigned char packet[] = {
4166     // public flags (8 byte connection_id)
4167     0x3C,
4168     // connection_id
4169     0x10, 0x32, 0x54, 0x76,
4170     0x98, 0xBA, 0xDC, 0xFE,
4171     // packet number
4172     0xBC, 0x9A, 0x78, 0x56,
4173     0x34, 0x12,
4174     // private flags (fec group & fec packet)
4175     0x06,
4176     // first fec protected packet offset
4177     0x01,
4178
4179     // redundancy
4180     'a',  'b',  'c',  'd',
4181     'e',  'f',  'g',  'h',
4182     'i',  'j',  'k',  'l',
4183     'm',  'n',  'o',  'p',
4184   };
4185   // clang-format on
4186
4187   scoped_ptr<QuicPacket> raw(new QuicPacket(
4188       AsChars(packet), arraysize(packet), false, PACKET_8BYTE_CONNECTION_ID,
4189       !kIncludeVersion, PACKET_6BYTE_PACKET_NUMBER));
4190   char buffer[kMaxPacketSize];
4191   scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPayload(
4192       ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize));
4193
4194   ASSERT_TRUE(encrypted.get() != nullptr);
4195   EXPECT_TRUE(CheckEncryption(packet_number, raw.get()));
4196 }
4197
4198 TEST_P(QuicFramerTest, EncryptPacketWithVersionFlag) {
4199   QuicPacketNumber packet_number = UINT64_C(0x123456789ABC);
4200   // clang-format off
4201   unsigned char packet[] = {
4202     // public flags (version, 8 byte connection_id)
4203     0x3D,
4204     // connection_id
4205     0x10, 0x32, 0x54, 0x76,
4206     0x98, 0xBA, 0xDC, 0xFE,
4207     // version tag
4208     'Q', '.', '1', '0',
4209     // packet number
4210     0xBC, 0x9A, 0x78, 0x56,
4211     0x34, 0x12,
4212     // private flags (fec group & fec flags)
4213     0x06,
4214     // first fec protected packet offset
4215     0x01,
4216
4217     // redundancy
4218     'a',  'b',  'c',  'd',
4219     'e',  'f',  'g',  'h',
4220     'i',  'j',  'k',  'l',
4221     'm',  'n',  'o',  'p',
4222   };
4223   // clang-format on
4224
4225   scoped_ptr<QuicPacket> raw(new QuicPacket(
4226       AsChars(packet), arraysize(packet), false, PACKET_8BYTE_CONNECTION_ID,
4227       kIncludeVersion, PACKET_6BYTE_PACKET_NUMBER));
4228   char buffer[kMaxPacketSize];
4229   scoped_ptr<QuicEncryptedPacket> encrypted(framer_.EncryptPayload(
4230       ENCRYPTION_NONE, packet_number, *raw, buffer, kMaxPacketSize));
4231
4232   ASSERT_TRUE(encrypted.get() != nullptr);
4233   EXPECT_TRUE(CheckEncryption(packet_number, raw.get()));
4234 }
4235
4236 TEST_P(QuicFramerTest, AckTruncationLargePacket) {
4237   QuicPacketHeader header;
4238   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
4239   header.public_header.reset_flag = false;
4240   header.public_header.version_flag = false;
4241   header.fec_flag = false;
4242   header.entropy_flag = false;
4243   header.packet_packet_number = UINT64_C(0x123456789ABC);
4244   header.fec_group = 0;
4245
4246   // Create a packet with just the ack.
4247   QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(300, 0u);
4248   QuicFrame frame;
4249   frame.type = ACK_FRAME;
4250   frame.ack_frame = &ack_frame;
4251   QuicFrames frames;
4252   frames.push_back(frame);
4253
4254   // Build an ack packet with truncation due to limit in number of nack ranges.
4255   scoped_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
4256   ASSERT_TRUE(raw_ack_packet != nullptr);
4257   char buffer[kMaxPacketSize];
4258   scoped_ptr<QuicEncryptedPacket> ack_packet(
4259       framer_.EncryptPayload(ENCRYPTION_NONE, header.packet_packet_number,
4260                              *raw_ack_packet, buffer, kMaxPacketSize));
4261   // Now make sure we can turn our ack packet back into an ack frame.
4262   ASSERT_TRUE(framer_.ProcessPacket(*ack_packet));
4263   ASSERT_EQ(1u, visitor_.ack_frames_.size());
4264   QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0];
4265   EXPECT_TRUE(processed_ack_frame.is_truncated);
4266   EXPECT_EQ(510u, processed_ack_frame.largest_observed);
4267   ASSERT_EQ(255u, processed_ack_frame.missing_packets.NumPackets());
4268   EXPECT_EQ(1u, processed_ack_frame.missing_packets.Min());
4269   EXPECT_EQ(509u, processed_ack_frame.missing_packets.Max());
4270 }
4271
4272 TEST_P(QuicFramerTest, AckTruncationSmallPacket) {
4273   QuicPacketHeader header;
4274   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
4275   header.public_header.reset_flag = false;
4276   header.public_header.version_flag = false;
4277   header.fec_flag = false;
4278   header.entropy_flag = false;
4279   header.packet_packet_number = UINT64_C(0x123456789ABC);
4280   header.fec_group = 0;
4281
4282   // Create a packet with just the ack.
4283   QuicAckFrame ack_frame = MakeAckFrameWithNackRanges(300, 0u);
4284   QuicFrame frame;
4285   frame.type = ACK_FRAME;
4286   frame.ack_frame = &ack_frame;
4287   QuicFrames frames;
4288   frames.push_back(frame);
4289
4290   // Build an ack packet with truncation due to limit in number of nack ranges.
4291   scoped_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames, 500));
4292   ASSERT_TRUE(raw_ack_packet != nullptr);
4293   char buffer[kMaxPacketSize];
4294   scoped_ptr<QuicEncryptedPacket> ack_packet(
4295       framer_.EncryptPayload(ENCRYPTION_NONE, header.packet_packet_number,
4296                              *raw_ack_packet, buffer, kMaxPacketSize));
4297   // Now make sure we can turn our ack packet back into an ack frame.
4298   ASSERT_TRUE(framer_.ProcessPacket(*ack_packet));
4299   ASSERT_EQ(1u, visitor_.ack_frames_.size());
4300   QuicAckFrame& processed_ack_frame = *visitor_.ack_frames_[0];
4301   EXPECT_TRUE(processed_ack_frame.is_truncated);
4302   EXPECT_EQ(476u, processed_ack_frame.largest_observed);
4303   ASSERT_EQ(238u, processed_ack_frame.missing_packets.NumPackets());
4304   EXPECT_EQ(1u, processed_ack_frame.missing_packets.Min());
4305   EXPECT_EQ(475u, processed_ack_frame.missing_packets.Max());
4306 }
4307
4308 TEST_P(QuicFramerTest, CleanTruncation) {
4309   QuicPacketHeader header;
4310   header.public_header.connection_id = UINT64_C(0xFEDCBA9876543210);
4311   header.public_header.reset_flag = false;
4312   header.public_header.version_flag = false;
4313   header.fec_flag = false;
4314   header.entropy_flag = true;
4315   header.packet_packet_number = UINT64_C(0x123456789ABC);
4316   header.fec_group = 0;
4317
4318   QuicAckFrame ack_frame;
4319   ack_frame.largest_observed = 201;
4320   ack_frame.missing_packets.Add(1, ack_frame.largest_observed);
4321
4322   // Create a packet with just the ack.
4323   QuicFrame frame;
4324   frame.type = ACK_FRAME;
4325   frame.ack_frame = &ack_frame;
4326   QuicFrames frames;
4327   frames.push_back(frame);
4328
4329   scoped_ptr<QuicPacket> raw_ack_packet(BuildDataPacket(header, frames));
4330   ASSERT_TRUE(raw_ack_packet != nullptr);
4331
4332   char buffer[kMaxPacketSize];
4333   scoped_ptr<QuicEncryptedPacket> ack_packet(
4334       framer_.EncryptPayload(ENCRYPTION_NONE, header.packet_packet_number,
4335                              *raw_ack_packet, buffer, kMaxPacketSize));
4336
4337   // Now make sure we can turn our ack packet back into an ack frame.
4338   ASSERT_TRUE(framer_.ProcessPacket(*ack_packet));
4339
4340   // Test for clean truncation of the ack by comparing the length of the
4341   // original packets to the re-serialized packets.
4342   frames.clear();
4343   frame.type = ACK_FRAME;
4344   frame.ack_frame = visitor_.ack_frames_[0];
4345   frames.push_back(frame);
4346
4347   size_t original_raw_length = raw_ack_packet->length();
4348   raw_ack_packet.reset(BuildDataPacket(header, frames));
4349   ASSERT_TRUE(raw_ack_packet != nullptr);
4350   EXPECT_EQ(original_raw_length, raw_ack_packet->length());
4351   ASSERT_TRUE(raw_ack_packet != nullptr);
4352 }
4353
4354 TEST_P(QuicFramerTest, EntropyFlagTest) {
4355   // clang-format off
4356   unsigned char packet[] = {
4357     // public flags (8 byte connection_id)
4358     0x3C,
4359     // connection_id
4360     0x10, 0x32, 0x54, 0x76,
4361     0x98, 0xBA, 0xDC, 0xFE,
4362     // packet number
4363     0xBC, 0x9A, 0x78, 0x56,
4364     0x34, 0x12,
4365     // private flags (Entropy)
4366     0x01,
4367
4368     // frame type (stream frame with fin and no length)
4369     0xDF,
4370     // stream id
4371     0x04, 0x03, 0x02, 0x01,
4372     // offset
4373     0x54, 0x76, 0x10, 0x32,
4374     0xDC, 0xFE, 0x98, 0xBA,
4375     // data
4376     'h',  'e',  'l',  'l',
4377     'o',  ' ',  'w',  'o',
4378     'r',  'l',  'd',  '!',
4379   };
4380   // clang-format on
4381
4382   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
4383   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
4384   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
4385   ASSERT_TRUE(visitor_.header_.get());
4386   EXPECT_TRUE(visitor_.header_->entropy_flag);
4387   EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash);
4388   EXPECT_FALSE(visitor_.header_->fec_flag);
4389 };
4390
4391 TEST_P(QuicFramerTest, FecEntropyTest) {
4392   // clang-format off
4393   unsigned char packet[] = {
4394     // public flags (8 byte connection_id)
4395     0x3C,
4396     // connection_id
4397     0x10, 0x32, 0x54, 0x76,
4398     0x98, 0xBA, 0xDC, 0xFE,
4399     // packet number
4400     0xBC, 0x9A, 0x78, 0x56,
4401     0x34, 0x12,
4402     // private flags (Entropy & fec group & FEC)
4403     0x07,
4404     // first fec protected packet offset
4405     0xFF,
4406
4407     // frame type (stream frame with fin and no length)
4408     0xDF,
4409     // stream id
4410     0x04, 0x03, 0x02, 0x01,
4411     // offset
4412     0x54, 0x76, 0x10, 0x32,
4413     0xDC, 0xFE, 0x98, 0xBA,
4414     // data
4415     'h',  'e',  'l',  'l',
4416     'o',  ' ',  'w',  'o',
4417     'r',  'l',  'd',  '!',
4418   };
4419   // clang-format on
4420
4421   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
4422   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
4423   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
4424   ASSERT_TRUE(visitor_.header_.get());
4425   EXPECT_TRUE(visitor_.header_->fec_flag);
4426   EXPECT_TRUE(visitor_.header_->entropy_flag);
4427   EXPECT_EQ(1 << 4, visitor_.header_->entropy_hash);
4428 };
4429
4430 TEST_P(QuicFramerTest, StopPacketProcessing) {
4431   // clang-format off
4432   unsigned char packet[] = {
4433     // public flags (8 byte connection_id)
4434     0x3C,
4435     // connection_id
4436     0x10, 0x32, 0x54, 0x76,
4437     0x98, 0xBA, 0xDC, 0xFE,
4438     // packet number
4439     0xBC, 0x9A, 0x78, 0x56,
4440     0x34, 0x12,
4441     // Entropy
4442     0x01,
4443
4444     // frame type (stream frame with fin)
4445     0xFF,
4446     // stream id
4447     0x04, 0x03, 0x02, 0x01,
4448     // offset
4449     0x54, 0x76, 0x10, 0x32,
4450     0xDC, 0xFE, 0x98, 0xBA,
4451     // data length
4452     0x0c, 0x00,
4453     // data
4454     'h',  'e',  'l',  'l',
4455     'o',  ' ',  'w',  'o',
4456     'r',  'l',  'd',  '!',
4457
4458     // frame type (ack frame)
4459     0x40,
4460     // entropy hash of sent packets till least awaiting - 1.
4461     0x14,
4462     // least packet number awaiting an ack
4463     0xA0, 0x9A, 0x78, 0x56,
4464     0x34, 0x12,
4465     // entropy hash of all received packets.
4466     0x43,
4467     // largest observed packet number
4468     0xBF, 0x9A, 0x78, 0x56,
4469     0x34, 0x12,
4470     // num missing packets
4471     0x01,
4472     // missing packet
4473     0xBE, 0x9A, 0x78, 0x56,
4474     0x34, 0x12,
4475   };
4476   // clang-format on
4477
4478   MockFramerVisitor visitor;
4479   framer_.set_visitor(&visitor);
4480   EXPECT_CALL(visitor, OnPacket());
4481   EXPECT_CALL(visitor, OnPacketHeader(_));
4482   EXPECT_CALL(visitor, OnStreamFrame(_)).WillOnce(Return(false));
4483   EXPECT_CALL(visitor, OnAckFrame(_)).Times(0);
4484   EXPECT_CALL(visitor, OnPacketComplete());
4485   EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_)).WillOnce(Return(true));
4486   EXPECT_CALL(visitor, OnUnauthenticatedHeader(_)).WillOnce(Return(true));
4487   EXPECT_CALL(visitor, OnDecryptedPacket(_));
4488
4489   QuicEncryptedPacket encrypted(AsChars(packet), arraysize(packet), false);
4490   EXPECT_TRUE(framer_.ProcessPacket(encrypted));
4491   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
4492 }
4493
4494 static char kTestString[] = "At least 20 characters.";
4495 static QuicStreamId kTestQuicStreamId = 1;
4496 static bool ExpectedStreamFrame(const QuicStreamFrame& frame) {
4497   return frame.stream_id == kTestQuicStreamId && !frame.fin &&
4498          frame.offset == 0 && frame.data == kTestString;
4499   // FIN is hard-coded false in ConstructEncryptedPacket.
4500   // Offset 0 is hard-coded in ConstructEncryptedPacket.
4501 }
4502
4503 // Verify that the packet returned by ConstructEncryptedPacket() can be properly
4504 // parsed by the framer.
4505 TEST_P(QuicFramerTest, ConstructEncryptedPacket) {
4506   // Since we are using ConstructEncryptedPacket, we have to set the framer's
4507   // crypto to be Null.
4508   framer_.SetDecrypter(ENCRYPTION_NONE, QuicDecrypter::Create(kNULL));
4509   framer_.SetEncrypter(ENCRYPTION_NONE, QuicEncrypter::Create(kNULL));
4510
4511   scoped_ptr<QuicEncryptedPacket> packet(ConstructEncryptedPacket(
4512       42, false, false, kTestQuicStreamId, kTestString,
4513       PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER));
4514
4515   MockFramerVisitor visitor;
4516   framer_.set_visitor(&visitor);
4517   EXPECT_CALL(visitor, OnPacket()).Times(1);
4518   EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_))
4519       .Times(1)
4520       .WillOnce(Return(true));
4521   EXPECT_CALL(visitor, OnUnauthenticatedHeader(_))
4522       .Times(1)
4523       .WillOnce(Return(true));
4524   EXPECT_CALL(visitor, OnPacketHeader(_)).Times(1).WillOnce(Return(true));
4525   EXPECT_CALL(visitor, OnDecryptedPacket(_)).Times(1);
4526   EXPECT_CALL(visitor, OnError(_)).Times(0);
4527   EXPECT_CALL(visitor, OnStreamFrame(_)).Times(0);
4528   EXPECT_CALL(visitor, OnStreamFrame(Truly(ExpectedStreamFrame))).Times(1);
4529   EXPECT_CALL(visitor, OnAckFrame(_)).Times(0);
4530   EXPECT_CALL(visitor, OnPacketComplete()).Times(1);
4531
4532   EXPECT_TRUE(framer_.ProcessPacket(*packet));
4533   EXPECT_EQ(QUIC_NO_ERROR, framer_.error());
4534 }
4535
4536 // Verify that the packet returned by ConstructMisFramedEncryptedPacket()
4537 // does cause the framer to return an error.
4538 TEST_P(QuicFramerTest, ConstructMisFramedEncryptedPacket) {
4539   // Since we are using ConstructEncryptedPacket, we have to set the framer's
4540   // crypto to be Null.
4541   framer_.SetDecrypter(ENCRYPTION_NONE, QuicDecrypter::Create(kNULL));
4542   framer_.SetEncrypter(ENCRYPTION_NONE, QuicEncrypter::Create(kNULL));
4543
4544   scoped_ptr<QuicEncryptedPacket> packet(ConstructMisFramedEncryptedPacket(
4545       42, false, false, kTestQuicStreamId, kTestString,
4546       PACKET_8BYTE_CONNECTION_ID, PACKET_6BYTE_PACKET_NUMBER, nullptr));
4547
4548   MockFramerVisitor visitor;
4549   framer_.set_visitor(&visitor);
4550   EXPECT_CALL(visitor, OnPacket()).Times(1);
4551   EXPECT_CALL(visitor, OnUnauthenticatedPublicHeader(_))
4552       .Times(1)
4553       .WillOnce(Return(true));
4554   EXPECT_CALL(visitor, OnUnauthenticatedHeader(_))
4555       .Times(1)
4556       .WillOnce(Return(true));
4557   EXPECT_CALL(visitor, OnPacketHeader(_)).Times(0);
4558   EXPECT_CALL(visitor, OnDecryptedPacket(_)).Times(1);
4559   EXPECT_CALL(visitor, OnError(_)).Times(1);
4560   EXPECT_CALL(visitor, OnStreamFrame(_)).Times(0);
4561   EXPECT_CALL(visitor, OnAckFrame(_)).Times(0);
4562   EXPECT_CALL(visitor, OnPacketComplete()).Times(0);
4563
4564   EXPECT_FALSE(framer_.ProcessPacket(*packet));
4565   EXPECT_EQ(QUIC_INVALID_PACKET_HEADER, framer_.error());
4566 }
4567
4568 }  // namespace test
4569 }  // namespace net