diff --git a/quic/core/quic_ietf_framer_test.cc b/quic/core/quic_ietf_framer_test.cc
deleted file mode 100644
index 07f933d..0000000
--- a/quic/core/quic_ietf_framer_test.cc
+++ /dev/null
@@ -1,1503 +0,0 @@
-// 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_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"
-#include "net/third_party/quiche/src/common/platform/api/quiche_arraysize.h"
-#include "net/third_party/quiche/src/common/platform/api/quiche_string_piece.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*/,
-                     quiche::QuicheStringPiece /*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 < QUICHE_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 < QUICHE_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];
-
-  quiche::QuicheStringPiece 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(QUICHE_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:
-    quiche::QuicheStringPiece 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_THAT(sink_frame.quic_error_code, IsQuicNoError());
-  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