// Copyright (c) 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// gunit tests for the IETF-format framer --- generally does a simple test
// for each framer; we generate the template object (eg
// QuicIetfStreamFrame) with the correct stuff in it, ask that a frame
// be serialized (call AppendIetf<mumble>) then deserialized (call
// ProcessIetf<mumble>) and then check that the gazintas and gazoutas
// are the same.
//
// We do minimal checking of the serialized frame
//
// We do look at various different values (resulting in different
// length varints, etc)

#include "net/third_party/quiche/src/quic/core/quic_framer.h"

#include <algorithm>
#include <cstdint>
#include <map>
#include <memory>
#include <string>
#include <vector>

#include "net/third_party/quiche/src/quic/core/crypto/null_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/null_encrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_decrypter.h"
#include "net/third_party/quiche/src/quic/core/crypto/quic_encrypter.h"
#include "net/third_party/quiche/src/quic/core/quic_data_reader.h"
#include "net/third_party/quiche/src/quic/core/quic_data_writer.h"
#include "net/third_party/quiche/src/quic/core/quic_packets.h"
#include "net/third_party/quiche/src/quic/core/quic_utils.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_arraysize.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_flags.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_logging.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_framer_peer.h"
#include "net/third_party/quiche/src/quic/test_tools/quic_test_utils.h"
#include "net/third_party/quiche/src/quic/test_tools/simple_data_producer.h"

namespace quic {
namespace test {
namespace {

const size_t kNormalPacketBufferSize = 1400;
// Several different stream ids, should be encoded
// in 8, 4, 2, and 1 byte, respectively. Last one
// checks that value==0 works.
// All stream IDs end in 0x0, so the client/server- initiated
// and Uni/Bi-directional bits are available to alter, as any
// given test may wish.
const QuicIetfStreamId kStreamId8 = UINT64_C(0x3EDCBA9876543210);
const QuicIetfStreamId kStreamId4 = UINT64_C(0x36543210);
const QuicIetfStreamId kStreamId2 = UINT64_C(0x3210);
const QuicIetfStreamId kStreamId1 = UINT64_C(0x10);
const QuicIetfStreamId kStreamId0 = UINT64_C(0x00);

// Ditto for the offsets.
const QuicIetfStreamOffset kOffset8 = UINT64_C(0x3210BA9876543210);
const QuicIetfStreamOffset kOffset4 = UINT64_C(0x32109876);
const QuicIetfStreamOffset kOffset2 = UINT64_C(0x3456);
const QuicIetfStreamOffset kOffset1 = UINT64_C(0x3f);
const QuicIetfStreamOffset kOffset0 = UINT64_C(0x00);

// Structures used to create various ack frames.

// Defines an ack frame to feed through the framer/deframer.
struct ack_frame {
  uint64_t delay_time;
  bool is_ack_ecn;
  QuicPacketCount ect_0_count;
  QuicPacketCount ect_1_count;
  QuicPacketCount ecn_ce_count;
  const std::vector<QuicAckBlock>& ranges;
  uint64_t expected_frame_type;
};

class TestQuicVisitor : public QuicFramerVisitorInterface {
 public:
  TestQuicVisitor() {}

  ~TestQuicVisitor() override {}

  void OnError(QuicFramer* f) override {
    QUIC_DLOG(INFO) << "QuicIetfFramer Error: "
                    << QuicErrorCodeToString(f->error()) << " (" << f->error()
                    << ")";
  }

  void OnPacket() override {}

  void OnPublicResetPacket(const QuicPublicResetPacket& /*packet*/) override {}

  void OnVersionNegotiationPacket(
      const QuicVersionNegotiationPacket& /*packet*/) override {}

  void OnRetryPacket(QuicConnectionId /*original_connection_id*/,
                     QuicConnectionId /*new_connection_id*/,
                     QuicStringPiece /*retry_token*/) override {}

  bool OnProtocolVersionMismatch(
      ParsedQuicVersion /*received_version*/) override {
    return false;
  }

  bool OnUnauthenticatedPublicHeader(
      const QuicPacketHeader& /*header*/) override {
    return true;
  }

  bool OnUnauthenticatedHeader(const QuicPacketHeader& /*header*/) override {
    return true;
  }

  void OnDecryptedPacket(EncryptionLevel /*level*/) override {}

  bool OnPacketHeader(const QuicPacketHeader& /*header*/) override {
    return true;
  }

  void OnCoalescedPacket(const QuicEncryptedPacket& /*packet*/) override {}

  void OnUndecryptablePacket(const QuicEncryptedPacket& /*packet*/,
                             EncryptionLevel /*decryption_level*/,
                             bool /*has_decryption_key*/) override {}

  bool OnStreamFrame(const QuicStreamFrame& /*frame*/) override { return true; }

  bool OnCryptoFrame(const QuicCryptoFrame& /*frame*/) override { return true; }

  bool OnAckFrameStart(QuicPacketNumber /*largest_acked*/,
                       QuicTime::Delta /*ack_delay_time*/) override {
    return true;
  }

  bool OnAckRange(QuicPacketNumber /*start*/,
                  QuicPacketNumber /*end*/) override {
    return true;
  }

  bool OnAckTimestamp(QuicPacketNumber /*packet_number*/,
                      QuicTime /*timestamp*/) override {
    return true;
  }

  bool OnAckFrameEnd(QuicPacketNumber /*start*/) override { return true; }

  bool OnStopWaitingFrame(const QuicStopWaitingFrame& /*frame*/) override {
    return true;
  }

  bool OnPaddingFrame(const QuicPaddingFrame& /*frame*/) override {
    return true;
  }

  bool OnPingFrame(const QuicPingFrame& /*frame*/) override { return true; }

  bool OnMessageFrame(const QuicMessageFrame& /*frame*/) override {
    return true;
  }

  void OnPacketComplete() override {}

  bool OnRstStreamFrame(const QuicRstStreamFrame& /*frame*/) override {
    return true;
  }

  bool OnConnectionCloseFrame(
      const QuicConnectionCloseFrame& /*frame*/) override {
    return true;
  }

  bool OnStopSendingFrame(const QuicStopSendingFrame& /*frame*/) override {
    return true;
  }

  bool OnPathChallengeFrame(const QuicPathChallengeFrame& /*frame*/) override {
    return true;
  }
  bool OnPathResponseFrame(const QuicPathResponseFrame& /*frame*/) override {
    return true;
  }

  bool OnGoAwayFrame(const QuicGoAwayFrame& /*frame*/) override { return true; }

  bool OnWindowUpdateFrame(const QuicWindowUpdateFrame& /*frame*/) override {
    return true;
  }

  bool OnBlockedFrame(const QuicBlockedFrame& /*frame*/) override {
    return true;
  }

  bool OnNewConnectionIdFrame(
      const QuicNewConnectionIdFrame& /*frame*/) override {
    return true;
  }

  bool OnRetireConnectionIdFrame(
      const QuicRetireConnectionIdFrame& /*frame*/) override {
    return true;
  }

  bool OnNewTokenFrame(const QuicNewTokenFrame& /*frame*/) override {
    return true;
  }

  bool IsValidStatelessResetToken(QuicUint128 /*token*/) const override {
    return true;
  }

  void OnAuthenticatedIetfStatelessResetPacket(
      const QuicIetfStatelessResetPacket& /*packet*/) override {}

  bool OnMaxStreamsFrame(const QuicMaxStreamsFrame& /*frame*/) override {
    return true;
  }

  bool OnStreamsBlockedFrame(
      const QuicStreamsBlockedFrame& /*frame*/) override {
    return true;
  }
};

class QuicIetfFramerTest : public QuicTestWithParam<ParsedQuicVersion> {
 public:
  QuicIetfFramerTest()
      : start_(QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(0x10)),
        framer_(AllSupportedVersions(),
                start_,
                Perspective::IS_SERVER,
                kQuicDefaultConnectionIdLength) {
    framer_.set_visitor(&visitor_);
  }

  // Utility functions to do actual framing/deframing.
  void TryStreamFrame(char* packet_buffer,
                      size_t packet_buffer_size,
                      const char* xmit_packet_data,
                      size_t xmit_packet_data_size,
                      QuicIetfStreamId stream_id,
                      QuicIetfStreamOffset offset,
                      bool fin_bit,
                      bool last_frame_bit,
                      QuicIetfFrameType frame_type) {
    // initialize a writer so that the serialized packet is placed in
    // packet_buffer.
    QuicDataWriter writer(packet_buffer_size, packet_buffer,
                          quiche::NETWORK_BYTE_ORDER);  // do not really care
                                                        // about endianness.
    // set up to define the source frame we wish to send.
    QuicStreamFrame source_stream_frame(
        stream_id, fin_bit, offset, xmit_packet_data, xmit_packet_data_size);

    // Write the frame to the packet buffer.
    EXPECT_TRUE(QuicFramerPeer::AppendIetfStreamFrame(
        &framer_, source_stream_frame, last_frame_bit, &writer));
    // Better have something in the packet buffer.
    EXPECT_NE(0u, writer.length());
    // Now set up a reader to read in the frame.
    QuicDataReader reader(packet_buffer, writer.length(),
                          quiche::NETWORK_BYTE_ORDER);

    // A StreamFrame to hold the results... we know the frame type,
    // put it into the QuicIetfStreamFrame
    QuicStreamFrame sink_stream_frame;
    if (xmit_packet_data_size) {
      EXPECT_EQ(sink_stream_frame.data_buffer, nullptr);
      EXPECT_EQ(sink_stream_frame.data_length, 0u);
    }

    EXPECT_TRUE(QuicFramerPeer::ProcessIetfStreamFrame(
        &framer_, &reader, frame_type, &sink_stream_frame));

    // Now check that the streamid, fin-bit, offset, and
    // data len all match the input.
    EXPECT_EQ(sink_stream_frame.stream_id, source_stream_frame.stream_id);
    EXPECT_EQ(sink_stream_frame.fin, source_stream_frame.fin);
    EXPECT_EQ(sink_stream_frame.data_length, source_stream_frame.data_length);
    if (frame_type & IETF_STREAM_FRAME_OFF_BIT) {
      // There was an offset in the frame, see if xmit and rcv vales equal.
      EXPECT_EQ(sink_stream_frame.offset, source_stream_frame.offset);
    } else {
      // Offset not in frame, so it better come out 0.
      EXPECT_EQ(sink_stream_frame.offset, 0u);
    }
    if (xmit_packet_data_size) {
      ASSERT_NE(sink_stream_frame.data_buffer, nullptr);
      ASSERT_NE(source_stream_frame.data_buffer, nullptr);
      EXPECT_EQ(strcmp(sink_stream_frame.data_buffer,
                       source_stream_frame.data_buffer),
                0);
    } else {
      // No data in the frame.
      EXPECT_EQ(source_stream_frame.data_length, 0u);
      EXPECT_EQ(sink_stream_frame.data_length, 0u);
    }
  }

  // Overall ack frame encode/decode/compare function
  //  Encodes an ack frame as specified at |*frame|
  //  Then decodes the frame,
  //  Then compares the two
  // Does some basic checking:
  //   - did the writer write something?
  //   - did the reader read the entire packet?
  //   - did the things the reader read match what the writer wrote?
  // Returns true if it all worked false if not.
  bool TryAckFrame(char* packet_buffer,
                   size_t /*packet_buffer_size*/,
                   struct ack_frame* frame) {
    QuicAckFrame transmit_frame = InitAckFrame(frame->ranges);
    if (frame->is_ack_ecn) {
      transmit_frame.ecn_counters_populated = true;
      transmit_frame.ect_0_count = frame->ect_0_count;
      transmit_frame.ect_1_count = frame->ect_1_count;
      transmit_frame.ecn_ce_count = frame->ecn_ce_count;
    }
    transmit_frame.ack_delay_time =
        QuicTime::Delta::FromMicroseconds(frame->delay_time);
    size_t expected_size =
        QuicFramerPeer::GetIetfAckFrameSize(&framer_, transmit_frame);

    // Make a writer so that the serialized packet is placed in
    // packet_buffer.
    QuicDataWriter writer(expected_size, packet_buffer,
                          quiche::NETWORK_BYTE_ORDER);

    // Write the frame to the packet buffer.
    EXPECT_TRUE(QuicFramerPeer::AppendIetfAckFrameAndTypeByte(
        &framer_, transmit_frame, &writer));

    size_t expected_frame_length = QuicFramerPeer::ComputeFrameLength(
        &framer_, QuicFrame(&transmit_frame), false,
        static_cast<QuicPacketNumberLength>(123456u));

    // Encoded length should match what ComputeFrameLength returns
    EXPECT_EQ(expected_frame_length, writer.length());
    // and what is in the buffer should be the expected size.
    EXPECT_EQ(expected_size, writer.length()) << "Frame is " << transmit_frame;
    // Now set up a reader to read in the frame.
    QuicDataReader reader(packet_buffer, writer.length(),
                          quiche::NETWORK_BYTE_ORDER);

    // read in the frame type
    uint8_t received_frame_type;
    EXPECT_TRUE(reader.ReadUInt8(&received_frame_type));
    EXPECT_EQ(frame->expected_frame_type, received_frame_type);

    // an AckFrame to hold the results
    QuicAckFrame receive_frame;

    EXPECT_TRUE(QuicFramerPeer::ProcessIetfAckFrame(
        &framer_, &reader, received_frame_type, &receive_frame));

    if (frame->is_ack_ecn &&
        (frame->ect_0_count || frame->ect_1_count || frame->ecn_ce_count)) {
      EXPECT_TRUE(receive_frame.ecn_counters_populated);
      EXPECT_EQ(receive_frame.ect_0_count, frame->ect_0_count);
      EXPECT_EQ(receive_frame.ect_1_count, frame->ect_1_count);
      EXPECT_EQ(receive_frame.ecn_ce_count, frame->ecn_ce_count);
    } else {
      EXPECT_FALSE(receive_frame.ecn_counters_populated);
      EXPECT_EQ(receive_frame.ect_0_count, 0u);
      EXPECT_EQ(receive_frame.ect_1_count, 0u);
      EXPECT_EQ(receive_frame.ecn_ce_count, 0u);
    }

    // Now check that the received frame matches the sent frame.
    EXPECT_EQ(transmit_frame.largest_acked, receive_frame.largest_acked);
    // The ~0x7 needs some explaining.  The ack frame format down shifts the
    // delay time by 3 (divide by 8) to allow for greater ranges in delay time.
    // Therefore, if we give the framer a delay time that is not an
    // even multiple of 8, the value that the deframer produces will
    // not be the same as what the framer got. The downshift on
    // framing and upshift on deframing results in clearing the 3
    // low-order bits ... The masking basically does the same thing,
    // so the compare works properly.
    return true;
  }

  // encode, decode, and check a Path Challenge frame.
  bool TryPathChallengeFrame(char* packet_buffer,
                             size_t packet_buffer_size,
                             const QuicPathFrameBuffer& data) {
    // Make a writer so that the serialized packet is placed in
    // packet_buffer.
    QuicDataWriter writer(packet_buffer_size, packet_buffer,
                          quiche::NETWORK_BYTE_ORDER);

    QuicPathChallengeFrame transmit_frame(0, data);

    // write the frame to the packet buffer.
    EXPECT_TRUE(QuicFramerPeer::AppendPathChallengeFrame(
        &framer_, transmit_frame, &writer));

    // Check for correct length in the packet buffer.
    EXPECT_EQ(kQuicPathChallengeFrameSize, writer.length());

    // now set up a reader to read in the frame.
    QuicDataReader reader(packet_buffer, writer.length(),
                          quiche::NETWORK_BYTE_ORDER);

    QuicPathChallengeFrame receive_frame;

    EXPECT_TRUE(QuicFramerPeer::ProcessPathChallengeFrame(&framer_, &reader,
                                                          &receive_frame));

    // Now check that the received frame matches the sent frame.
    EXPECT_EQ(
        0, memcmp(transmit_frame.data_buffer.data(),
                  receive_frame.data_buffer.data(), kQuicPathFrameBufferSize));
    return true;
  }

  // encode, decode, and check a Path Response frame.
  bool TryPathResponseFrame(char* packet_buffer,
                            size_t packet_buffer_size,
                            const QuicPathFrameBuffer& data) {
    // Make a writer so that the serialized packet is placed in
    // packet_buffer.
    QuicDataWriter writer(packet_buffer_size, packet_buffer,
                          quiche::NETWORK_BYTE_ORDER);

    QuicPathResponseFrame transmit_frame(0, data);

    // Write the frame to the packet buffer.
    EXPECT_TRUE(QuicFramerPeer::AppendPathResponseFrame(
        &framer_, transmit_frame, &writer));

    // Check for correct length in the packet buffer.
    EXPECT_EQ(kQuicPathResponseFrameSize, writer.length());

    // Set up a reader to read in the frame.
    QuicDataReader reader(packet_buffer, writer.length(),
                          quiche::NETWORK_BYTE_ORDER);

    QuicPathResponseFrame receive_frame;

    EXPECT_TRUE(QuicFramerPeer::ProcessPathResponseFrame(&framer_, &reader,
                                                         &receive_frame));

    // Now check that the received frame matches the sent frame.
    EXPECT_EQ(
        0, memcmp(transmit_frame.data_buffer.data(),
                  receive_frame.data_buffer.data(), kQuicPathFrameBufferSize));
    return true;
  }

  // Test the Serialization/deserialization of a Reset Stream Frame.
  void TryResetFrame(char* packet_buffer,
                     size_t packet_buffer_size,
                     QuicStreamId stream_id,
                     uint16_t error_code,
                     QuicStreamOffset final_offset) {
    // Initialize a writer so that the serialized packet is placed in
    // packet_buffer.
    QuicDataWriter writer(packet_buffer_size, packet_buffer,
                          quiche::NETWORK_BYTE_ORDER);

    QuicRstStreamFrame transmit_frame(static_cast<QuicControlFrameId>(1),
                                      stream_id, error_code, final_offset);

    // Write the frame to the packet buffer.
    EXPECT_TRUE(QuicFramerPeer::AppendIetfResetStreamFrame(
        &framer_, transmit_frame, &writer));
    // Check that the size of the serialzed frame is in the allowed range (3 to
    // 24 bytes, inclusive).
    EXPECT_LT(2u, writer.length());
    EXPECT_GT(25u, writer.length());
    // Now set up a reader to read in the thing in.
    QuicDataReader reader(packet_buffer, writer.length(),
                          quiche::NETWORK_BYTE_ORDER);

    // A QuicRstStreamFrame to hold the results
    QuicRstStreamFrame receive_frame;
    EXPECT_TRUE(QuicFramerPeer::ProcessIetfResetStreamFrame(&framer_, &reader,
                                                            &receive_frame));

    // Now check that the received values match the input.
    EXPECT_EQ(receive_frame.stream_id, transmit_frame.stream_id);
    EXPECT_EQ(receive_frame.ietf_error_code, transmit_frame.ietf_error_code);
    EXPECT_EQ(receive_frame.byte_offset, transmit_frame.byte_offset);
  }

  void TryMaxStreamsFrame(QuicStreamCount stream_count,
                          bool unidirectional,
                          bool stream_id_server_initiated) {
    char packet_buffer[kNormalPacketBufferSize];
    memset(packet_buffer, 0, sizeof(packet_buffer));

    Perspective old_perspective = framer_.perspective();
    // Set up the writer and transmit QuicMaxStreamsFrame
    QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                          quiche::NETWORK_BYTE_ORDER);

    // Set the perspective of the sender. If the stream id is supposed to
    // be server-initiated, then the sender of the MAX_STREAMS should be
    // a client, and vice versa. Do this prior to constructing the frame or
    // generating the packet, so that any internal dependencies are satisfied.
    QuicFramerPeer::SetPerspective(&framer_, (stream_id_server_initiated)
                                                 ? Perspective::IS_CLIENT
                                                 : Perspective::IS_SERVER);
    QuicMaxStreamsFrame transmit_frame(0, stream_count, unidirectional);

    // Add the frame.
    EXPECT_TRUE(QuicFramerPeer::AppendMaxStreamsFrame(&framer_, transmit_frame,
                                                      &writer));

    // Check that buffer length is in the expected range
    EXPECT_LE(1u, writer.length());
    EXPECT_GE(8u, writer.length());

    // Set the perspective for the receiver.
    QuicFramerPeer::SetPerspective(&framer_, (stream_id_server_initiated)
                                                 ? Perspective::IS_SERVER
                                                 : Perspective::IS_CLIENT);

    // Set up reader and empty receive QuicPaddingFrame.
    QuicDataReader reader(packet_buffer, writer.length(),
                          quiche::NETWORK_BYTE_ORDER);
    QuicMaxStreamsFrame receive_frame;

    // Deframe it
    EXPECT_TRUE(QuicFramerPeer::ProcessMaxStreamsFrame(
        &framer_, &reader, &receive_frame,
        (unidirectional) ? IETF_MAX_STREAMS_UNIDIRECTIONAL
                         : IETF_MAX_STREAMS_BIDIRECTIONAL))
        << " Error: " << framer_.detailed_error();

    // Now check that received and sent data are equivalent
    EXPECT_EQ(stream_count, receive_frame.stream_count);
    EXPECT_EQ(transmit_frame.stream_count, receive_frame.stream_count);
    QuicFramerPeer::SetPerspective(&framer_, old_perspective);
  }

  void TryStreamsBlockedFrame(QuicStreamCount stream_count,
                              bool unidirectional,
                              bool stream_id_server_initiated) {
    char packet_buffer[kNormalPacketBufferSize];
    memset(packet_buffer, 0, sizeof(packet_buffer));

    Perspective old_perspective = framer_.perspective();
    // Set up the writer and transmit QuicStreamsBlockedFrame
    QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                          quiche::NETWORK_BYTE_ORDER);

    // Set the perspective of the sender. If the stream id is supposed to
    // be server-initiated, then the sender of the STREAMS_BLOCKED should be
    // a client, and vice versa. Do this prior to constructing the frame or
    // generating the packet, so that any internal dependencies are satisfied.
    QuicFramerPeer::SetPerspective(&framer_, (stream_id_server_initiated)
                                                 ? Perspective::IS_SERVER
                                                 : Perspective::IS_CLIENT);
    QuicStreamsBlockedFrame transmit_frame(0, stream_count, unidirectional);

    // Add the frame.
    EXPECT_TRUE(QuicFramerPeer::AppendStreamsBlockedFrame(
        &framer_, transmit_frame, &writer));

    // Check that buffer length is in the expected range
    EXPECT_LE(1u, writer.length());
    EXPECT_GE(8u, writer.length());

    // Set the perspective for the receiver.
    QuicFramerPeer::SetPerspective(&framer_, (stream_id_server_initiated)
                                                 ? Perspective::IS_CLIENT
                                                 : Perspective::IS_SERVER);

    // Set up reader and empty receive QuicPaddingFrame.
    QuicDataReader reader(packet_buffer, writer.length(),
                          quiche::NETWORK_BYTE_ORDER);
    QuicStreamsBlockedFrame receive_frame;

    // Deframe it
    EXPECT_TRUE(QuicFramerPeer::ProcessStreamsBlockedFrame(
        &framer_, &reader, &receive_frame,
        (unidirectional) ? IETF_STREAMS_BLOCKED_UNIDIRECTIONAL
                         : IETF_STREAMS_BLOCKED_BIDIRECTIONAL));

    // Now check that received and sent data are equivalent
    EXPECT_EQ(stream_count, receive_frame.stream_count);
    EXPECT_EQ(transmit_frame.stream_count, receive_frame.stream_count);
    QuicFramerPeer::SetPerspective(&framer_, old_perspective);
  }

  QuicTime start_;
  QuicFramer framer_;
  test::TestQuicVisitor visitor_;
};

struct stream_frame_variant {
  QuicIetfStreamId stream_id;
  QuicIetfStreamOffset offset;
  bool fin_bit;
  bool last_frame_bit;
  uint8_t frame_type;
} stream_frame_to_test[] = {
#define IETF_STREAM0 (((uint8_t)IETF_STREAM))

#define IETF_STREAM1 (((uint8_t)IETF_STREAM) | IETF_STREAM_FRAME_FIN_BIT)

#define IETF_STREAM2 (((uint8_t)IETF_STREAM) | IETF_STREAM_FRAME_LEN_BIT)

#define IETF_STREAM3                                    \
  (((uint8_t)IETF_STREAM) | IETF_STREAM_FRAME_LEN_BIT | \
   IETF_STREAM_FRAME_FIN_BIT)

#define IETF_STREAM4 (((uint8_t)IETF_STREAM) | IETF_STREAM_FRAME_OFF_BIT)

#define IETF_STREAM5                                    \
  (((uint8_t)IETF_STREAM) | IETF_STREAM_FRAME_OFF_BIT | \
   IETF_STREAM_FRAME_FIN_BIT)

#define IETF_STREAM6                                    \
  (((uint8_t)IETF_STREAM) | IETF_STREAM_FRAME_OFF_BIT | \
   IETF_STREAM_FRAME_LEN_BIT)

#define IETF_STREAM7                                    \
  (((uint8_t)IETF_STREAM) | IETF_STREAM_FRAME_OFF_BIT | \
   IETF_STREAM_FRAME_LEN_BIT | IETF_STREAM_FRAME_FIN_BIT)

    {kStreamId8, kOffset8, true, false, IETF_STREAM7},
    {kStreamId8, kOffset8, false, false, IETF_STREAM6},
    {kStreamId8, kOffset4, true, false, IETF_STREAM7},
    {kStreamId8, kOffset4, false, false, IETF_STREAM6},
    {kStreamId8, kOffset2, true, false, IETF_STREAM7},
    {kStreamId8, kOffset2, false, false, IETF_STREAM6},
    {kStreamId8, kOffset1, true, false, IETF_STREAM7},
    {kStreamId8, kOffset1, false, false, IETF_STREAM6},
    {kStreamId8, kOffset0, true, false, IETF_STREAM3},
    {kStreamId8, kOffset0, false, false, IETF_STREAM2},
    {kStreamId4, kOffset8, true, false, IETF_STREAM7},
    {kStreamId4, kOffset8, false, false, IETF_STREAM6},
    {kStreamId4, kOffset4, true, false, IETF_STREAM7},
    {kStreamId4, kOffset4, false, false, IETF_STREAM6},
    {kStreamId4, kOffset2, true, false, IETF_STREAM7},
    {kStreamId4, kOffset2, false, false, IETF_STREAM6},
    {kStreamId4, kOffset1, true, false, IETF_STREAM7},
    {kStreamId4, kOffset1, false, false, IETF_STREAM6},
    {kStreamId4, kOffset0, true, false, IETF_STREAM3},
    {kStreamId4, kOffset0, false, false, IETF_STREAM2},
    {kStreamId2, kOffset8, true, false, IETF_STREAM7},
    {kStreamId2, kOffset8, false, false, IETF_STREAM6},
    {kStreamId2, kOffset4, true, false, IETF_STREAM7},
    {kStreamId2, kOffset4, false, false, IETF_STREAM6},
    {kStreamId2, kOffset2, true, false, IETF_STREAM7},
    {kStreamId2, kOffset2, false, false, IETF_STREAM6},
    {kStreamId2, kOffset1, true, false, IETF_STREAM7},
    {kStreamId2, kOffset1, false, false, IETF_STREAM6},
    {kStreamId2, kOffset0, true, false, IETF_STREAM3},
    {kStreamId2, kOffset0, false, false, IETF_STREAM2},
    {kStreamId1, kOffset8, true, false, IETF_STREAM7},
    {kStreamId1, kOffset8, false, false, IETF_STREAM6},
    {kStreamId1, kOffset4, true, false, IETF_STREAM7},
    {kStreamId1, kOffset4, false, false, IETF_STREAM6},
    {kStreamId1, kOffset2, true, false, IETF_STREAM7},
    {kStreamId1, kOffset2, false, false, IETF_STREAM6},
    {kStreamId1, kOffset1, true, false, IETF_STREAM7},
    {kStreamId1, kOffset1, false, false, IETF_STREAM6},
    {kStreamId1, kOffset0, true, false, IETF_STREAM3},
    {kStreamId1, kOffset0, false, false, IETF_STREAM2},
    {kStreamId0, kOffset8, true, false, IETF_STREAM7},
    {kStreamId0, kOffset8, false, false, IETF_STREAM6},
    {kStreamId0, kOffset4, true, false, IETF_STREAM7},
    {kStreamId0, kOffset4, false, false, IETF_STREAM6},
    {kStreamId0, kOffset2, true, false, IETF_STREAM7},
    {kStreamId0, kOffset2, false, false, IETF_STREAM6},
    {kStreamId0, kOffset1, true, false, IETF_STREAM7},
    {kStreamId0, kOffset1, false, false, IETF_STREAM6},
    {kStreamId0, kOffset0, true, false, IETF_STREAM3},
    {kStreamId0, kOffset0, false, false, IETF_STREAM2},

    {kStreamId8, kOffset8, true, true, IETF_STREAM5},
    {kStreamId8, kOffset8, false, true, IETF_STREAM4},
    {kStreamId8, kOffset4, true, true, IETF_STREAM5},
    {kStreamId8, kOffset4, false, true, IETF_STREAM4},
    {kStreamId8, kOffset2, true, true, IETF_STREAM5},
    {kStreamId8, kOffset2, false, true, IETF_STREAM4},
    {kStreamId8, kOffset1, true, true, IETF_STREAM5},
    {kStreamId8, kOffset1, false, true, IETF_STREAM4},
    {kStreamId8, kOffset0, true, true, IETF_STREAM1},
    {kStreamId8, kOffset0, false, true, IETF_STREAM0},
    {kStreamId4, kOffset8, true, true, IETF_STREAM5},
    {kStreamId4, kOffset8, false, true, IETF_STREAM4},
    {kStreamId4, kOffset4, true, true, IETF_STREAM5},
    {kStreamId4, kOffset4, false, true, IETF_STREAM4},
    {kStreamId4, kOffset2, true, true, IETF_STREAM5},
    {kStreamId4, kOffset2, false, true, IETF_STREAM4},
    {kStreamId4, kOffset1, true, true, IETF_STREAM5},
    {kStreamId4, kOffset1, false, true, IETF_STREAM4},
    {kStreamId4, kOffset0, true, true, IETF_STREAM1},
    {kStreamId4, kOffset0, false, true, IETF_STREAM0},
    {kStreamId2, kOffset8, true, true, IETF_STREAM5},
    {kStreamId2, kOffset8, false, true, IETF_STREAM4},
    {kStreamId2, kOffset4, true, true, IETF_STREAM5},
    {kStreamId2, kOffset4, false, true, IETF_STREAM4},
    {kStreamId2, kOffset2, true, true, IETF_STREAM5},
    {kStreamId2, kOffset2, false, true, IETF_STREAM4},
    {kStreamId2, kOffset1, true, true, IETF_STREAM5},
    {kStreamId2, kOffset1, false, true, IETF_STREAM4},
    {kStreamId2, kOffset0, true, true, IETF_STREAM1},
    {kStreamId2, kOffset0, false, true, IETF_STREAM0},
    {kStreamId1, kOffset8, true, true, IETF_STREAM5},
    {kStreamId1, kOffset8, false, true, IETF_STREAM4},
    {kStreamId1, kOffset4, true, true, IETF_STREAM5},
    {kStreamId1, kOffset4, false, true, IETF_STREAM4},
    {kStreamId1, kOffset2, true, true, IETF_STREAM5},
    {kStreamId1, kOffset2, false, true, IETF_STREAM4},
    {kStreamId1, kOffset1, true, true, IETF_STREAM5},
    {kStreamId1, kOffset1, false, true, IETF_STREAM4},
    {kStreamId1, kOffset0, true, true, IETF_STREAM1},
    {kStreamId1, kOffset0, false, true, IETF_STREAM0},
    {kStreamId0, kOffset8, true, true, IETF_STREAM5},
    {kStreamId0, kOffset8, false, true, IETF_STREAM4},
    {kStreamId0, kOffset4, true, true, IETF_STREAM5},
    {kStreamId0, kOffset4, false, true, IETF_STREAM4},
    {kStreamId0, kOffset2, true, true, IETF_STREAM5},
    {kStreamId0, kOffset2, false, true, IETF_STREAM4},
    {kStreamId0, kOffset1, true, true, IETF_STREAM5},
    {kStreamId0, kOffset1, false, true, IETF_STREAM4},
    {kStreamId0, kOffset0, true, true, IETF_STREAM1},
    {kStreamId0, kOffset0, false, true, IETF_STREAM0},
};

TEST_F(QuicIetfFramerTest, StreamFrame) {
  char packet_buffer[kNormalPacketBufferSize];
  const char* transmit_packet_data =
      "this is a test of some packet data, "
      "can do a simple strcmp to see if the "
      "input and output are the same!";

  size_t transmit_packet_data_len = strlen(transmit_packet_data) + 1;
  for (size_t i = 0; i < QUIC_ARRAYSIZE(stream_frame_to_test); ++i) {
    SCOPED_TRACE(i);
    struct stream_frame_variant* variant = &stream_frame_to_test[i];
    TryStreamFrame(packet_buffer, sizeof(packet_buffer), transmit_packet_data,
                   transmit_packet_data_len, variant->stream_id,
                   variant->offset, variant->fin_bit, variant->last_frame_bit,
                   static_cast<QuicIetfFrameType>(variant->frame_type));
  }
}
// As the previous test, but with no data.
TEST_F(QuicIetfFramerTest, ZeroLengthStreamFrame) {
  char packet_buffer[kNormalPacketBufferSize];

  for (size_t i = 0; i < QUIC_ARRAYSIZE(stream_frame_to_test); ++i) {
    SCOPED_TRACE(i);
    struct stream_frame_variant* variant = &stream_frame_to_test[i];
    TryStreamFrame(packet_buffer, sizeof(packet_buffer),
                   /* xmit_packet_data = */ NULL,
                   /* xmit_packet_data_size = */ 0, variant->stream_id,
                   variant->offset, variant->fin_bit, variant->last_frame_bit,
                   static_cast<QuicIetfFrameType>(variant->frame_type));
  }
}

TEST_F(QuicIetfFramerTest, CryptoFrame) {
  SimpleDataProducer data_producer;
  framer_.set_data_producer(&data_producer);
  char packet_buffer[kNormalPacketBufferSize];

  QuicStringPiece frame_data("This is a CRYPTO frame.");

  QuicStreamOffset offsets[] = {kOffset8, kOffset4, kOffset2, kOffset1,
                                kOffset0};
  for (QuicStreamOffset offset : offsets) {
    QuicCryptoFrame frame(ENCRYPTION_INITIAL, offset, frame_data.length());
    data_producer.SaveCryptoData(ENCRYPTION_INITIAL, offset, frame_data);

    QuicDataWriter writer(QUIC_ARRAYSIZE(packet_buffer), packet_buffer,
                          quiche::NETWORK_BYTE_ORDER);

    // Write the frame.
    EXPECT_TRUE(QuicFramerPeer::AppendCryptoFrame(&framer_, frame, &writer));
    EXPECT_NE(0u, writer.length());
    // Read it back.
    QuicDataReader reader(packet_buffer, writer.length(),
                          quiche::NETWORK_BYTE_ORDER);
    QuicCryptoFrame read_frame;
    EXPECT_TRUE(
        QuicFramerPeer::ProcessCryptoFrame(&framer_, &reader, &read_frame));

    // Check that the frames match:
    QuicStringPiece read_data(read_frame.data_buffer, read_frame.data_length);
    EXPECT_EQ(read_frame.data_length, frame.data_length);
    EXPECT_EQ(read_frame.offset, frame.offset);
    EXPECT_EQ(read_data, frame_data);
  }
}

TEST_F(QuicIetfFramerTest, ConnectionClose) {
  char packet_buffer[kNormalPacketBufferSize];

  // initialize a writer so that the serialized packet is placed in
  // packet_buffer.
  QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                        quiche::NETWORK_BYTE_ORDER);

  std::string test_string = "Ich Bin Ein Jelly Donut?";
  QuicConnectionCloseFrame sent_frame(QUIC_VERSION_99, QUIC_NO_ERROR,
                                      test_string,
                                      /*transport_close_frame_type=*/123);

  // write the frame to the packet buffer.
  EXPECT_TRUE(QuicFramerPeer::AppendIetfConnectionCloseFrame(
      &framer_, sent_frame, &writer));

  // better have something in the packet buffer.
  EXPECT_NE(0u, writer.length());

  // now set up a reader to read in the frame.
  QuicDataReader reader(packet_buffer, writer.length(),
                        quiche::NETWORK_BYTE_ORDER);

  // a QuicConnectionCloseFrame to hold the results.
  QuicConnectionCloseFrame sink_frame;

  EXPECT_TRUE(QuicFramerPeer::ProcessIetfConnectionCloseFrame(
      &framer_, &reader, IETF_QUIC_TRANSPORT_CONNECTION_CLOSE, &sink_frame));

  // Now check that received == sent
  EXPECT_EQ(sent_frame.quic_error_code, sink_frame.quic_error_code);
  EXPECT_EQ(sink_frame.quic_error_code, QUIC_NO_ERROR);
  EXPECT_EQ(sink_frame.error_details, test_string);
  EXPECT_EQ(sink_frame.close_type, sent_frame.close_type);
  EXPECT_EQ(sent_frame.close_type, IETF_QUIC_TRANSPORT_CONNECTION_CLOSE);
}

TEST_F(QuicIetfFramerTest, ApplicationClose) {
  char packet_buffer[kNormalPacketBufferSize];

  // initialize a writer so that the serialized packet is placed in
  // packet_buffer.
  QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                        quiche::NETWORK_BYTE_ORDER);

  std::string test_string = "Ich Bin Ein Jelly Donut?";
  QuicConnectionCloseFrame sent_frame(QUIC_VERSION_99, QUIC_LAST_ERROR,
                                      test_string,
                                      /*transport_close_frame_type=*/0);

  // write the frame to the packet buffer.
  EXPECT_TRUE(QuicFramerPeer::AppendIetfConnectionCloseFrame(
      &framer_, sent_frame, &writer));

  // better have something in the packet buffer.
  EXPECT_NE(0u, writer.length());

  // now set up a reader to read in the frame.
  QuicDataReader reader(packet_buffer, writer.length(),
                        quiche::NETWORK_BYTE_ORDER);

  // a QuicConnectionCloseFrame to hold the results.
  QuicConnectionCloseFrame sink_frame;

  EXPECT_TRUE(QuicFramerPeer::ProcessIetfConnectionCloseFrame(
      &framer_, &reader, IETF_QUIC_APPLICATION_CONNECTION_CLOSE, &sink_frame));

  // Now check that received == sent
  EXPECT_EQ(sink_frame.quic_error_code, QUIC_LAST_ERROR);
  EXPECT_EQ(sent_frame.quic_error_code, sink_frame.quic_error_code);
  EXPECT_EQ(sink_frame.error_details, test_string);
  EXPECT_EQ(sent_frame.close_type, IETF_QUIC_APPLICATION_CONNECTION_CLOSE);
  EXPECT_EQ(sent_frame.close_type, sink_frame.close_type);
}

// Testing for the IETF ACK framer.
// clang-format off
struct ack_frame ack_frame_variants[] = {
    {90000,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1000), QuicPacketNumber(2001)}},
     IETF_ACK},
    {0,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1000), QuicPacketNumber(2001)}},
     IETF_ACK},
    {1,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(2)},
      {QuicPacketNumber(5), QuicPacketNumber(6)}},
     IETF_ACK},
    {63,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(2)},
      {QuicPacketNumber(5), QuicPacketNumber(6)}},
     IETF_ACK},
    {64,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(2)},
      {QuicPacketNumber(3), QuicPacketNumber(4)},
      {QuicPacketNumber(5), QuicPacketNumber(6)},
      {QuicPacketNumber(7), QuicPacketNumber(8)},
      {QuicPacketNumber(9), QuicPacketNumber(10)},
      {QuicPacketNumber(11), QuicPacketNumber(12)}},
     IETF_ACK},
    {10000,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(2)},
      {QuicPacketNumber(3), QuicPacketNumber(4)},
      {QuicPacketNumber(5), QuicPacketNumber(6)},
      {QuicPacketNumber(7), QuicPacketNumber(8)},
      {QuicPacketNumber(9), QuicPacketNumber(10)},
      {QuicPacketNumber(11), QuicPacketNumber(12)}},
     IETF_ACK},
    {100000000,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(2)},
      {QuicPacketNumber(3), QuicPacketNumber(4)},
      {QuicPacketNumber(5), QuicPacketNumber(6)},
      {QuicPacketNumber(7), QuicPacketNumber(8)},
      {QuicPacketNumber(9), QuicPacketNumber(10)},
      {QuicPacketNumber(11), QuicPacketNumber(12)}},
     IETF_ACK},
    {0,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(65)}},
     IETF_ACK},
    {9223372036854775807,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(11)},
      {QuicPacketNumber(74), QuicPacketNumber(138)}},
     IETF_ACK},
    // This ack is for packets 60 & 125. There are 64 packets in the gap.
    // The encoded value is gap_size - 1, or 63. Crosses a VarInt62 encoding
    // boundary...
    {1,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(60), QuicPacketNumber(61)},
      {QuicPacketNumber(125), QuicPacketNumber(126)}},
     IETF_ACK},
    {2,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(130)}},
     IETF_ACK},
    {3,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(195)}},
     IETF_ACK},
    {4,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(194)}},
     IETF_ACK},
    {5,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(193)}},
     IETF_ACK},
    {6,
     false,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(192)}},
     IETF_ACK},
    // declare some ack_ecn frames to try.
    {6,
     false,
     100,
     200,
     300,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(192)}},
     IETF_ACK},
    {6,
     true,
     100,
     200,
     300,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(192)}},
     IETF_ACK_ECN},
    {6,
     true,
     100,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(192)}},
     IETF_ACK_ECN},
    {6,
     true,
     0,
     200,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(192)}},
     IETF_ACK_ECN},
    {6,
     true,
     0,
     0,
     300,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(192)}},
     IETF_ACK_ECN},
    {6,
     true,
     0,
     0,
     0,
     {{QuicPacketNumber(1), QuicPacketNumber(65)},
      {QuicPacketNumber(129), QuicPacketNumber(192)}},
     IETF_ACK},
};
// clang-format on

TEST_F(QuicIetfFramerTest, AckFrame) {
  char packet_buffer[kNormalPacketBufferSize];
  for (auto ack_frame_variant : ack_frame_variants) {
    EXPECT_TRUE(
        TryAckFrame(packet_buffer, sizeof(packet_buffer), &ack_frame_variant));
  }
}

// Test the case of having a QuicAckFrame with no ranges in it.  By
// examination of the Google Quic Ack code and tests, this case should
// be handled as an ack with no "ranges after the first"; the
// AckBlockCount should be 0 and the FirstAckBlock should be
// |LargestAcked| - 1 (number of packets preceding the LargestAcked.
TEST_F(QuicIetfFramerTest, AckFrameNoRanges) {
  char packet_buffer[kNormalPacketBufferSize];

  // Make a writer so that the serialized packet is placed in
  // packet_buffer.
  QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                        quiche::NETWORK_BYTE_ORDER);

  QuicAckFrame transmit_frame;
  transmit_frame.largest_acked = QuicPacketNumber(1);
  transmit_frame.ack_delay_time = QuicTime::Delta::FromMicroseconds(0);

  size_t expected_size =
      QuicFramerPeer::GetIetfAckFrameSize(&framer_, transmit_frame);
  // Write the frame to the packet buffer.
  EXPECT_TRUE(QuicFramerPeer::AppendIetfAckFrameAndTypeByte(
      &framer_, transmit_frame, &writer));

  uint8_t packet[] = {
      0x02,  // type, IETF_ACK
      0x01,  // largest_acked,
      0x00,  // delay
      0x00,  // count of additional ack blocks
      0x00,  // size of first ack block (packets preceding largest_acked)
  };
  EXPECT_EQ(expected_size, sizeof(packet));
  EXPECT_EQ(sizeof(packet), writer.length());
  EXPECT_EQ(0, memcmp(packet, packet_buffer, writer.length()));

  // Now set up a reader to read in the frame.
  QuicDataReader reader(packet_buffer, writer.length(),
                        quiche::NETWORK_BYTE_ORDER);

  // an AckFrame to hold the results
  QuicAckFrame receive_frame;

  // read in the frame type
  uint8_t received_frame_type;
  EXPECT_TRUE(reader.ReadUInt8(&received_frame_type));
  EXPECT_EQ(received_frame_type, IETF_ACK);

  EXPECT_TRUE(QuicFramerPeer::ProcessIetfAckFrame(&framer_, &reader, IETF_ACK,
                                                  &receive_frame));

  // Now check that the received frame matches the sent frame.
  EXPECT_EQ(transmit_frame.largest_acked, receive_frame.largest_acked);
}

TEST_F(QuicIetfFramerTest, PathChallengeFrame) {
  // Double-braces needed on some platforms due to
  // https://bugs.llvm.org/show_bug.cgi?id=21629
  QuicPathFrameBuffer buffer0 = {{0, 0, 0, 0, 0, 0, 0, 0}};
  QuicPathFrameBuffer buffer1 = {
      {0x80, 0x91, 0xa2, 0xb3, 0xc4, 0xd5, 0xe5, 0xf7}};
  char packet_buffer[kNormalPacketBufferSize];
  EXPECT_TRUE(
      TryPathChallengeFrame(packet_buffer, sizeof(packet_buffer), buffer0));
  EXPECT_TRUE(
      TryPathChallengeFrame(packet_buffer, sizeof(packet_buffer), buffer1));
}

TEST_F(QuicIetfFramerTest, PathResponseFrame) {
  // Double-braces needed on some platforms due to
  // https://bugs.llvm.org/show_bug.cgi?id=21629
  QuicPathFrameBuffer buffer0 = {{0, 0, 0, 0, 0, 0, 0, 0}};
  QuicPathFrameBuffer buffer1 = {
      {0x80, 0x91, 0xa2, 0xb3, 0xc4, 0xd5, 0xe5, 0xf7}};
  char packet_buffer[kNormalPacketBufferSize];
  EXPECT_TRUE(
      TryPathResponseFrame(packet_buffer, sizeof(packet_buffer), buffer0));
  EXPECT_TRUE(
      TryPathResponseFrame(packet_buffer, sizeof(packet_buffer), buffer1));
}

TEST_F(QuicIetfFramerTest, ResetStreamFrame) {
  char packet_buffer[kNormalPacketBufferSize];
  struct resets {
    QuicStreamId stream_id;
    uint16_t error_code;
    QuicStreamOffset final_offset;
  } reset_frames[] = {
      {0, 55, 0},
      {0x10, 73, 0x300},
  };
  for (auto reset : reset_frames) {
    TryResetFrame(packet_buffer, sizeof(packet_buffer), reset.stream_id,
                  reset.error_code, reset.final_offset);
  }
}

TEST_F(QuicIetfFramerTest, StopSendingFrame) {
  char packet_buffer[kNormalPacketBufferSize];

  // Make a writer so that the serialized packet is placed in
  // packet_buffer.
  QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                        quiche::NETWORK_BYTE_ORDER);

  QuicStopSendingFrame transmit_frame;
  transmit_frame.stream_id = 12345;
  transmit_frame.application_error_code = 543;

  // Write the frame to the packet buffer.
  EXPECT_TRUE(QuicFramerPeer::AppendStopSendingFrame(&framer_, transmit_frame,
                                                     &writer));
  // Check that the number of bytes in the buffer is in the
  // allowed range.
  EXPECT_LE(3u, writer.length());
  EXPECT_GE(10u, writer.length());

  QuicDataReader reader(packet_buffer, writer.length(),
                        quiche::NETWORK_BYTE_ORDER);

  // A frame to hold the results
  QuicStopSendingFrame receive_frame;

  EXPECT_TRUE(QuicFramerPeer::ProcessStopSendingFrame(&framer_, &reader,
                                                      &receive_frame));

  // Verify that the transmitted and received values are the same.
  EXPECT_EQ(receive_frame.stream_id, 12345u);
  EXPECT_EQ(receive_frame.application_error_code, 543u);
  EXPECT_EQ(receive_frame.stream_id, transmit_frame.stream_id);
  EXPECT_EQ(receive_frame.application_error_code,
            transmit_frame.application_error_code);
}

TEST_F(QuicIetfFramerTest, MaxDataFrame) {
  char packet_buffer[kNormalPacketBufferSize];
  QuicStreamOffset window_sizes[] = {0,       1,        2,        5,       10,
                                     20,      50,       100,      200,     500,
                                     1000000, kOffset8, kOffset4, kOffset2};
  for (QuicStreamOffset window_size : window_sizes) {
    memset(packet_buffer, 0, sizeof(packet_buffer));

    // Set up the writer and transmit QuicWindowUpdateFrame
    QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                          quiche::NETWORK_BYTE_ORDER);
    QuicWindowUpdateFrame transmit_frame(0, 99, window_size);

    // Add the frame.
    EXPECT_TRUE(
        QuicFramerPeer::AppendMaxDataFrame(&framer_, transmit_frame, &writer));

    // Check that the number of bytes in the buffer is in the expected range.
    EXPECT_LE(1u, writer.length());
    EXPECT_GE(8u, writer.length());

    // Set up reader and an empty QuicWindowUpdateFrame
    QuicDataReader reader(packet_buffer, writer.length(),
                          quiche::NETWORK_BYTE_ORDER);
    QuicWindowUpdateFrame receive_frame;

    // Deframe it
    EXPECT_TRUE(
        QuicFramerPeer::ProcessMaxDataFrame(&framer_, &reader, &receive_frame));

    // Now check that the received data equals the sent data.
    EXPECT_EQ(transmit_frame.max_data, window_size);
    EXPECT_EQ(transmit_frame.max_data, receive_frame.max_data);
    EXPECT_EQ(QuicUtils::GetInvalidStreamId(framer_.transport_version()),
              receive_frame.stream_id);
  }
}

TEST_F(QuicIetfFramerTest, MaxStreamDataFrame) {
  char packet_buffer[kNormalPacketBufferSize];
  QuicStreamOffset window_sizes[] = {0,       1,        2,        5,       10,
                                     20,      50,       100,      200,     500,
                                     1000000, kOffset8, kOffset4, kOffset2};
  QuicIetfStreamId stream_ids[] = {kStreamId4, kStreamId2, kStreamId1,
                                   kStreamId0};

  for (QuicIetfStreamId stream_id : stream_ids) {
    for (QuicStreamOffset window_size : window_sizes) {
      memset(packet_buffer, 0, sizeof(packet_buffer));

      // Set up the writer and transmit QuicWindowUpdateFrame
      QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                            quiche::NETWORK_BYTE_ORDER);
      QuicWindowUpdateFrame transmit_frame(0, stream_id, window_size);

      // Add the frame.
      EXPECT_TRUE(QuicFramerPeer::AppendMaxStreamDataFrame(
          &framer_, transmit_frame, &writer));

      // Check that number of bytes in the buffer is in the expected range.
      EXPECT_LE(2u, writer.length());
      EXPECT_GE(16u, writer.length());

      // Set up reader and empty receive QuicPaddingFrame.
      QuicDataReader reader(packet_buffer, writer.length(),
                            quiche::NETWORK_BYTE_ORDER);
      QuicWindowUpdateFrame receive_frame;

      // Deframe it
      EXPECT_TRUE(QuicFramerPeer::ProcessMaxStreamDataFrame(&framer_, &reader,
                                                            &receive_frame));

      // Now check that received data and sent data are equal.
      EXPECT_EQ(transmit_frame.max_data, window_size);
      EXPECT_EQ(transmit_frame.max_data, receive_frame.max_data);
      EXPECT_EQ(stream_id, receive_frame.stream_id);
      EXPECT_EQ(transmit_frame.stream_id, receive_frame.stream_id);
    }
  }
}

TEST_F(QuicIetfFramerTest, MaxStreamsFrame) {
  QuicStreamCount stream_counts[] = {0x3fffffff, 0x3fff, 0x3f, 0x1};

  for (QuicStreamCount stream_count : stream_counts) {
    // Cover all four combinations of uni/bi-directional and
    // server-/client- initiation.
    TryMaxStreamsFrame(stream_count, /*unidirectional=*/true,
                       /*stream_id_server_initiated=*/true);
    TryMaxStreamsFrame(stream_count, /*unidirectional=*/true,
                       /*stream_id_server_initiated=*/false);
    TryMaxStreamsFrame(stream_count, /*unidirectional=*/false,
                       /*stream_id_server_initiated=*/true);
    TryMaxStreamsFrame(stream_count, /*unidirectional=*/false,
                       /*stream_id_server_initiated=*/false);
  }
}

TEST_F(QuicIetfFramerTest, BlockedFrame) {
  char packet_buffer[kNormalPacketBufferSize];
  QuicStreamOffset offsets[] = {kOffset8, kOffset4, kOffset2, kOffset1,
                                kOffset0};

  for (QuicStreamOffset offset : offsets) {
    memset(packet_buffer, 0, sizeof(packet_buffer));

    // Set up the writer and transmit QuicBlockedFrame
    QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                          quiche::NETWORK_BYTE_ORDER);
    QuicBlockedFrame transmit_frame(
        0, QuicUtils::GetInvalidStreamId(framer_.transport_version()), offset);

    // Add the frame.
    EXPECT_TRUE(QuicFramerPeer::AppendIetfBlockedFrame(&framer_, transmit_frame,
                                                       &writer));

    // Check that buffer length is in the expected range
    EXPECT_LE(1u, writer.length());
    EXPECT_GE(8u, writer.length());

    // Set up reader and empty receive QuicFrame.
    QuicDataReader reader(packet_buffer, writer.length(),
                          quiche::NETWORK_BYTE_ORDER);
    QuicBlockedFrame receive_frame;

    // Deframe it
    EXPECT_TRUE(QuicFramerPeer::ProcessIetfBlockedFrame(&framer_, &reader,
                                                        &receive_frame));

    // Check that received and sent data are equivalent
    EXPECT_EQ(QuicUtils::GetInvalidStreamId(framer_.transport_version()),
              receive_frame.stream_id);
    EXPECT_EQ(offset, receive_frame.offset);
    EXPECT_EQ(transmit_frame.offset, receive_frame.offset);
  }
}

TEST_F(QuicIetfFramerTest, StreamBlockedFrame) {
  char packet_buffer[kNormalPacketBufferSize];
  QuicStreamOffset offsets[] = {0,       1,        2,        5,       10,
                                20,      50,       100,      200,     500,
                                1000000, kOffset8, kOffset4, kOffset2};
  QuicIetfStreamId stream_ids[] = {kStreamId4, kStreamId2, kStreamId1,
                                   kStreamId0};

  for (QuicIetfStreamId stream_id : stream_ids) {
    for (QuicStreamOffset offset : offsets) {
      memset(packet_buffer, 0, sizeof(packet_buffer));

      // Set up the writer and transmit QuicWindowUpdateFrame
      QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                            quiche::NETWORK_BYTE_ORDER);
      QuicBlockedFrame transmit_frame(0, stream_id, offset);

      // Add the frame.
      EXPECT_TRUE(QuicFramerPeer::AppendStreamBlockedFrame(
          &framer_, transmit_frame, &writer));

      // Check that number of bytes in the buffer is in the expected range.
      EXPECT_LE(2u, writer.length());
      EXPECT_GE(16u, writer.length());

      // Set up reader and empty receive QuicPaddingFrame.
      QuicDataReader reader(packet_buffer, writer.length(),
                            quiche::NETWORK_BYTE_ORDER);
      QuicBlockedFrame receive_frame;

      // Deframe it
      EXPECT_TRUE(QuicFramerPeer::ProcessStreamBlockedFrame(&framer_, &reader,
                                                            &receive_frame));

      // Now check that received == sent
      EXPECT_EQ(transmit_frame.offset, offset);
      EXPECT_EQ(transmit_frame.offset, receive_frame.offset);
      EXPECT_EQ(stream_id, receive_frame.stream_id);
      EXPECT_EQ(transmit_frame.stream_id, receive_frame.stream_id);
    }
  }
}

TEST_F(QuicIetfFramerTest, StreamsBlockedFrame) {
  QuicStreamCount stream_counts[] = {0x3fffffff, 0x3fff, 0x3f, 0x1};

  for (QuicStreamCount stream_count : stream_counts) {
    TryStreamsBlockedFrame(stream_count,
                           /*unidirectional=*/false,
                           /*stream_id_server_initiated=*/false);
    TryStreamsBlockedFrame(stream_count,
                           /*unidirectional=*/false,
                           /*stream_id_server_initiated=*/true);
    TryStreamsBlockedFrame(stream_count,
                           /*unidirectional=*/true,
                           /*stream_id_server_initiated=*/false);
    TryStreamsBlockedFrame(stream_count,
                           /*unidirectional=*/true,
                           /*stream_id_server_initiated=*/true);
  }
}

TEST_F(QuicIetfFramerTest, NewConnectionIdFrame) {
  char packet_buffer[kNormalPacketBufferSize];

  QuicNewConnectionIdFrame transmit_frame;
  transmit_frame.connection_id = TestConnectionId(UINT64_C(0x0edcba9876543201));
  transmit_frame.sequence_number = 0x01020304;
  transmit_frame.retire_prior_to = 0x00020304;
  // The token is defined as a uint128 -- a 16-byte integer.
  // The value is set in this manner because we want each
  // byte to have a specific value so that the binary
  // packet check (below) is good. If we used integer
  // operations (eg. "token = 0x12345...") then the bytes
  // would be set in host order.
  unsigned char token_bytes[] = {0x00, 0x01, 0x02, 0x03, 0x04, 0x05,
                                 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
                                 0x0c, 0x0d, 0x0e, 0x0f};
  memcpy(&transmit_frame.stateless_reset_token, token_bytes,
         sizeof(transmit_frame.stateless_reset_token));

  memset(packet_buffer, 0, sizeof(packet_buffer));

  // Set up the writer and transmit a QuicNewConnectionIdFrame
  QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                        quiche::NETWORK_BYTE_ORDER);

  // Add the frame.
  EXPECT_TRUE(QuicFramerPeer::AppendNewConnectionIdFrame(
      &framer_, transmit_frame, &writer));
  // clang-format off
  uint8_t packet[] = {
    // sequence number, 0x80 for varint62 encoding
    0x80 + 0x01, 0x02, 0x03, 0x04,
    // retire_prior_to, 0x80 for varint62 encoding
    0x80 + 0x00, 0x02, 0x03, 0x04,
    // new connection id length, is not varint62 encoded.
    0x08,
    // new connection id, is not varint62 encoded.
    0x0E, 0xDC, 0xBA, 0x98, 0x76, 0x54, 0x32, 0x01,
    // the reset token:
    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
    0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f
  };
  // clang-format on

  // Check that buffer length is correct
  EXPECT_EQ(sizeof(packet), writer.length());
  EXPECT_EQ(0, memcmp(packet_buffer, packet, sizeof(packet)));

  // Set up reader and empty receive QuicPaddingFrame.
  QuicDataReader reader(packet_buffer, writer.length(),
                        quiche::NETWORK_BYTE_ORDER);
  QuicNewConnectionIdFrame receive_frame;

  // Deframe it
  EXPECT_TRUE(QuicFramerPeer::ProcessNewConnectionIdFrame(&framer_, &reader,
                                                          &receive_frame));

  // Now check that received == sent
  EXPECT_EQ(transmit_frame.connection_id, receive_frame.connection_id);
  EXPECT_EQ(transmit_frame.sequence_number, receive_frame.sequence_number);
  EXPECT_EQ(transmit_frame.retire_prior_to, receive_frame.retire_prior_to);
  EXPECT_EQ(transmit_frame.stateless_reset_token,
            receive_frame.stateless_reset_token);
}

TEST_F(QuicIetfFramerTest, RetireConnectionIdFrame) {
  char packet_buffer[kNormalPacketBufferSize];

  QuicRetireConnectionIdFrame transmit_frame;
  transmit_frame.sequence_number = 0x01020304;

  memset(packet_buffer, 0, sizeof(packet_buffer));

  // Set up the writer and transmit QuicRetireConnectionIdFrame
  QuicDataWriter writer(sizeof(packet_buffer), packet_buffer,
                        quiche::NETWORK_BYTE_ORDER);

  // Add the frame.
  EXPECT_TRUE(QuicFramerPeer::AppendRetireConnectionIdFrame(
      &framer_, transmit_frame, &writer));
  // Check that buffer length is correct
  EXPECT_EQ(4u, writer.length());
  // clang-format off
  uint8_t packet[] = {
    // sequence number, 0x80 for varint62 encoding
    0x80 + 0x01, 0x02, 0x03, 0x04,
  };

  // clang-format on
  EXPECT_EQ(0, memcmp(packet_buffer, packet, sizeof(packet)));

  // Set up reader and empty receive QuicPaddingFrame.
  QuicDataReader reader(packet_buffer, writer.length(),
                        quiche::NETWORK_BYTE_ORDER);
  QuicRetireConnectionIdFrame receive_frame;

  // Deframe it
  EXPECT_TRUE(QuicFramerPeer::ProcessRetireConnectionIdFrame(&framer_, &reader,
                                                             &receive_frame));

  // Now check that received == sent
  EXPECT_EQ(transmit_frame.sequence_number, receive_frame.sequence_number);
}

}  // namespace
}  // namespace test
}  // namespace quic