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