quic_framer_test.cc | Explore in Territory

// Copyright (c) 2012 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.

#include "quiche/quic/core/quic_framer.h"

#include <algorithm>
#include <cstdint>
#include <cstring>
#include <limits>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <utility>
#include <vector>

#include "absl/base/macros.h"
#include "absl/memory/memory.h"
#include "absl/strings/escaping.h"
#include "absl/strings/match.h"
#include "absl/strings/string_view.h"
#include "quiche/quic/core/crypto/null_decrypter.h"
#include "quiche/quic/core/crypto/null_encrypter.h"
#include "quiche/quic/core/crypto/quic_decrypter.h"
#include "quiche/quic/core/crypto/quic_encrypter.h"
#include "quiche/quic/core/frames/quic_reset_stream_at_frame.h"
#include "quiche/quic/core/quic_connection_id.h"
#include "quiche/quic/core/quic_error_codes.h"
#include "quiche/quic/core/quic_packets.h"
#include "quiche/quic/core/quic_types.h"
#include "quiche/quic/core/quic_utils.h"
#include "quiche/quic/core/quic_versions.h"
#include "quiche/quic/platform/api/quic_expect_bug.h"
#include "quiche/quic/platform/api/quic_flags.h"
#include "quiche/quic/platform/api/quic_ip_address.h"
#include "quiche/quic/platform/api/quic_ip_address_family.h"
#include "quiche/quic/platform/api/quic_logging.h"
#include "quiche/quic/platform/api/quic_test.h"
#include "quiche/quic/test_tools/quic_framer_peer.h"
#include "quiche/quic/test_tools/quic_test_utils.h"
#include "quiche/quic/test_tools/simple_data_producer.h"
#include "quiche/common/test_tools/quiche_test_utils.h"

_;
ContainerEq;
Optional;
Return;

namespace quic {
namespace test {
namespace {

const uint64_t kEpoch = …1) << 32;
const uint64_t kMask = …;
const uint8_t kPacket0ByteConnectionId = …;
const uint8_t kPacket8ByteConnectionId = …;
constexpr size_t kTagSize = …;

const StatelessResetToken kTestStatelessResetToken{ … };

// Use fields in which each byte is distinct to ensure that every byte is
// framed correctly. The values are otherwise arbitrary.
QuicConnectionId FramerTestConnectionId() { … }

QuicConnectionId FramerTestConnectionIdPlusOne() { … }

QuicConnectionId FramerTestConnectionIdNineBytes() { … }

const QuicPacketNumber kPacketNumber = …;
const QuicPacketNumber kSmallLargestObserved = …;
const QuicPacketNumber kSmallMissingPacket = …;
const QuicPacketNumber kLeastUnacked = …;
const QuicStreamId kStreamId = …0x01020304);
// Note that the high 4 bits of the stream offset must be less than 0x40
// in order to ensure that the value can be encoded using VarInt62 encoding.
const QuicStreamOffset kStreamOffset = …0x3A98FEDC32107654);
const QuicPublicResetNonceProof kNonceProof = …0xABCDEF0123456789);

// In testing that we can ack the full range of packets...
// This is the largest packet number that can be represented in IETF QUIC
// varint62 format.
const QuicPacketNumber kLargestIetfLargestObserved = …;
// Encodings for the two bits in a VarInt62 that
// describe the length of the VarInt61. For binary packet
// formats in this file, the convention is to code the
// first byte as
//   kVarInt62FourBytes + 0x<value_in_that_byte>
const uint8_t kVarInt62OneByte = …;
const uint8_t kVarInt62TwoBytes = …;
const uint8_t kVarInt62FourBytes = …;
const uint8_t kVarInt62EightBytes = …;

class TestEncrypter : public QuicEncrypter { … };

class TestDecrypter : public QuicDecrypter { … };

std::unique_ptr<QuicEncryptedPacket> EncryptPacketWithTagAndPhase(
    const QuicPacket& packet, uint8_t tag, bool phase) { … }

class TestQuicVisitor : public QuicFramerVisitorInterface { … };

// Simple struct for defining a packet's content, and associated
// parse error.
struct PacketFragment { … };

PacketFragments;

class QuicFramerTest : public QuicTestWithParam<ParsedQuicVersion> { … };

// Multiple test cases of QuicFramerTest use byte arrays to define packets for
// testing, and these byte arrays contain the QUIC version. This macro explodes
// the 32-bit version into four bytes in network order. Since it uses methods of
// QuicFramerTest, it is only valid to use this in a QuicFramerTest.
#define QUIC_VERSION_BYTES …

// Run all framer tests with all supported versions of QUIC.
INSTANTIATE_TEST_SUITE_P(…);

TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearEpochStart) { … }

TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearEpochEnd) { … }

// Next check where we're in a non-zero epoch to verify we handle
// reverse wrapping, too.
TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearPrevEpoch) { … }

TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearNextEpoch) { … }

TEST_P(QuicFramerTest, CalculatePacketNumberFromWireNearNextMax) { … }

TEST_P(QuicFramerTest, EmptyPacket) { … }

TEST_P(QuicFramerTest, LargePacket) { … }

TEST_P(QuicFramerTest, LongPacketHeader) { … }

TEST_P(QuicFramerTest, LongPacketHeaderWithBothConnectionIds) { … }

TEST_P(QuicFramerTest, AllZeroPacketParsingFails) { … }

TEST_P(QuicFramerTest, ParsePublicHeader) { … }

TEST_P(QuicFramerTest, ParsePublicHeaderProxBadSourceConnectionIdLength) { … }

TEST_P(QuicFramerTest, ClientConnectionIdFromShortHeaderToClient) { … }

// In short header packets from client to server, the client connection ID
// is omitted, but the framer adds it to the header struct using its
// last serialized client connection ID. This test ensures that this
// mechanism behaves as expected.
TEST_P(QuicFramerTest, ClientConnectionIdFromShortHeaderToServer) { … }

TEST_P(QuicFramerTest, PacketHeaderWith0ByteConnectionId) { … }

TEST_P(QuicFramerTest, PacketHeaderWithVersionFlag) { … }

TEST_P(QuicFramerTest, PacketHeaderWith4BytePacketNumber) { … }

TEST_P(QuicFramerTest, PacketHeaderWith2BytePacketNumber) { … }

TEST_P(QuicFramerTest, PacketHeaderWith1BytePacketNumber) { … }

TEST_P(QuicFramerTest, PacketNumberDecreasesThenIncreases) { … }

TEST_P(QuicFramerTest, PacketWithDiversificationNonce) { … }

TEST_P(QuicFramerTest, LargePublicFlagWithMismatchedVersions) { … }

TEST_P(QuicFramerTest, PaddingFrame) { … }

TEST_P(QuicFramerTest, StreamFrame) { … }

// Test an empty (no data) stream frame.
TEST_P(QuicFramerTest, EmptyStreamFrame) { … }

TEST_P(QuicFramerTest, MissingDiversificationNonce) { … }

TEST_P(QuicFramerTest, StreamFrame2ByteStreamId) { … }

TEST_P(QuicFramerTest, StreamFrame1ByteStreamId) { … }

TEST_P(QuicFramerTest, StreamFrameWithVersion) { … }

TEST_P(QuicFramerTest, RejectPacket) { … }

TEST_P(QuicFramerTest, RejectPublicHeader) { … }

TEST_P(QuicFramerTest, AckFrameOneAckBlock) { … }

// This test checks that the ack frame processor correctly identifies
// and handles the case where the first ack block is larger than the
// largest_acked packet.
TEST_P(QuicFramerTest, FirstAckFrameUnderflow) { … }

// This test checks that the ack frame processor correctly identifies
// and handles the case where the third ack block's gap is larger than the
// available space in the ack range.
TEST_P(QuicFramerTest, ThirdAckBlockUnderflowGap) { … }

// This test checks that the ack frame processor correctly identifies
// and handles the case where the third ack block's length is larger than the
// available space in the ack range.
TEST_P(QuicFramerTest, ThirdAckBlockUnderflowAck) { … }

// Tests a variety of ack block wrap scenarios. For example, if the
// N-1th block causes packet 0 to be acked, then a gap would wrap
// around to 0x3fffffff ffffffff... Make sure we detect this
// condition.
TEST_P(QuicFramerTest, AckBlockUnderflowGapWrap) { … }

// As AckBlockUnderflowGapWrap, but in this test, it's the ack
// component of the ack-block that causes the wrap, not the gap.
TEST_P(QuicFramerTest, AckBlockUnderflowAckWrap) { … }

// An ack block that acks the entire range, 1...0x3fffffffffffffff
TEST_P(QuicFramerTest, AckBlockAcksEverything) { … }

// This test looks for a malformed ack where
//  - There is a largest-acked value (that is, the frame is acking
//    something,
//  - But the length of the first ack block is 0 saying that no frames
//    are being acked with the largest-acked value or there are no
//    additional ack blocks.
//
TEST_P(QuicFramerTest, AckFrameFirstAckBlockLengthZero) { … }

TEST_P(QuicFramerTest, AckFrameOneAckBlockMaxLength) { … }

// Tests ability to handle multiple ackblocks after the first ack
// block. Non-version-99 tests include multiple timestamps as well.
TEST_P(QuicFramerTest, AckFrameTwoTimeStampsMultipleAckBlocks) { … }

TEST_P(QuicFramerTest, AckFrameMultipleReceiveTimestampRanges) { … }

TEST_P(QuicFramerTest, AckFrameReceiveTimestampWithExponent) { … }

TEST_P(QuicFramerTest, AckFrameReceiveTimestampGapTooHigh) { … }

TEST_P(QuicFramerTest, AckFrameReceiveTimestampCountTooHigh) { … }

TEST_P(QuicFramerTest, AckFrameReceiveTimestampDeltaTooHigh) { … }

TEST_P(QuicFramerTest, AckFrameTimeStampDeltaTooHigh) { … }

TEST_P(QuicFramerTest, AckFrameTimeStampSecondDeltaTooHigh) { … }

TEST_P(QuicFramerTest, NewStopWaitingFrame) { … }

TEST_P(QuicFramerTest, InvalidNewStopWaitingFrame) { … }

TEST_P(QuicFramerTest, RstStreamFrame) { … }

TEST_P(QuicFramerTest, ConnectionCloseFrame) { … }

TEST_P(QuicFramerTest, ConnectionCloseFrameWithUnknownErrorCode) { … }

// As above, but checks that for Google-QUIC, if there happens
// to be an ErrorCode string at the start of the details, it is
// NOT extracted/parsed/folded/spindled/and/mutilated.
TEST_P(QuicFramerTest, ConnectionCloseFrameWithExtractedInfoIgnoreGCuic) { … }

// Test the CONNECTION_CLOSE/Application variant.
TEST_P(QuicFramerTest, ApplicationCloseFrame) { … }

// Check that we can extract an error code from an application close.
TEST_P(QuicFramerTest, ApplicationCloseFrameExtract) { … }

TEST_P(QuicFramerTest, GoAwayFrame) { … }

TEST_P(QuicFramerTest, GoAwayFrameWithUnknownErrorCode) { … }

TEST_P(QuicFramerTest, WindowUpdateFrame) { … }

TEST_P(QuicFramerTest, MaxDataFrame) { … }

TEST_P(QuicFramerTest, MaxStreamDataFrame) { … }

TEST_P(QuicFramerTest, BlockedFrame) { … }

TEST_P(QuicFramerTest, PingFrame) { … }

TEST_P(QuicFramerTest, HandshakeDoneFrame) { … }

TEST_P(QuicFramerTest, ParseAckFrequencyFrame) { … }

TEST_P(QuicFramerTest, ParseResetStreamAtFrame) { … }

TEST_P(QuicFramerTest, ParseInvalidResetStreamAtFrame) { … }

TEST_P(QuicFramerTest, MessageFrame) { … }

TEST_P(QuicFramerTest, IetfStatelessResetPacket) { … }

TEST_P(QuicFramerTest, IetfStatelessResetPacketInvalidStatelessResetToken) { … }

TEST_P(QuicFramerTest, VersionNegotiationPacketClient) { … }

TEST_P(QuicFramerTest, VersionNegotiationPacketServer) { … }

TEST_P(QuicFramerTest, ParseIetfRetryPacket) { … }

TEST_P(QuicFramerTest, BuildPaddingFramePacket) { … }

TEST_P(QuicFramerTest, BuildStreamFramePacketWithNewPaddingFrame) { … }

TEST_P(QuicFramerTest, Build4ByteSequenceNumberPaddingFramePacket) { … }

TEST_P(QuicFramerTest, Build2ByteSequenceNumberPaddingFramePacket) { … }

TEST_P(QuicFramerTest, Build1ByteSequenceNumberPaddingFramePacket) { … }

TEST_P(QuicFramerTest, BuildStreamFramePacket) { … }

TEST_P(QuicFramerTest, BuildStreamFramePacketWithVersionFlag) { … }

TEST_P(QuicFramerTest, BuildCryptoFramePacket) { … }

TEST_P(QuicFramerTest, CryptoFrame) { … }

TEST_P(QuicFramerTest, BuildOldVersionNegotiationPacket) { … }

TEST_P(QuicFramerTest, BuildVersionNegotiationPacket) { … }

TEST_P(QuicFramerTest, BuildVersionNegotiationPacketWithClientConnectionId) { … }

TEST_P(QuicFramerTest, BuildAckFramePacketOneAckBlock) { … }

TEST_P(QuicFramerTest, BuildAckReceiveTimestampsFrameMultipleRanges) { … }

TEST_P(QuicFramerTest, BuildAckReceiveTimestampsFrameExceedsMaxTimestamps) { … }

TEST_P(QuicFramerTest, BuildAckReceiveTimestampsFrameWithExponentEncoding) { … }

TEST_P(QuicFramerTest, BuildAndProcessAckReceiveTimestampsWithMultipleRanges) { … }

TEST_P(QuicFramerTest,
       BuildAndProcessAckReceiveTimestampsExceedsMaxTimestamps) { … }

TEST_P(QuicFramerTest,
       BuildAndProcessAckReceiveTimestampsWithExponentNoTruncation) { … }

TEST_P(QuicFramerTest,
       BuildAndProcessAckReceiveTimestampsWithExponentTruncation) { … }

TEST_P(QuicFramerTest, AckReceiveTimestamps) { … }

TEST_P(QuicFramerTest, AckReceiveTimestampsPacketOutOfOrder) { … }

// If there's insufficient room for IETF ack receive timestamps, don't write any
// timestamp ranges.
TEST_P(QuicFramerTest, IetfAckReceiveTimestampsTruncate) { … }

// If there are too many ack ranges, they will be truncated to make room for a
// timestamp range count of 0.
TEST_P(QuicFramerTest, IetfAckReceiveTimestampsAckRangeTruncation) { … }

TEST_P(QuicFramerTest, BuildAckFramePacketOneAckBlockMaxLength) { … }

TEST_P(QuicFramerTest, BuildAckFramePacketMultipleAckBlocks) { … }

TEST_P(QuicFramerTest, BuildAckFramePacketMaxAckBlocks) { … }

TEST_P(QuicFramerTest, BuildRstFramePacketQuic) { … }

TEST_P(QuicFramerTest, BuildCloseFramePacket) { … }

TEST_P(QuicFramerTest, BuildCloseFramePacketExtendedInfo) { … }

TEST_P(QuicFramerTest, BuildTruncatedCloseFramePacket) { … }

TEST_P(QuicFramerTest, BuildApplicationCloseFramePacket) { … }

TEST_P(QuicFramerTest, BuildTruncatedApplicationCloseFramePacket) { … }

TEST_P(QuicFramerTest, BuildGoAwayPacket) { … }

TEST_P(QuicFramerTest, BuildTruncatedGoAwayPacket) { … }

TEST_P(QuicFramerTest, BuildWindowUpdatePacket) { … }

TEST_P(QuicFramerTest, BuildMaxStreamDataPacket) { … }

TEST_P(QuicFramerTest, BuildMaxDataPacket) { … }

TEST_P(QuicFramerTest, BuildBlockedPacket) { … }

TEST_P(QuicFramerTest, BuildPingPacket) { … }

TEST_P(QuicFramerTest, BuildHandshakeDonePacket) { … }

TEST_P(QuicFramerTest, BuildAckFrequencyPacket) { … }

TEST_P(QuicFramerTest, BuildResetStreamAtPacket) { … }

TEST_P(QuicFramerTest, BuildMessagePacket) { … }

// Test that the MTU discovery packet is serialized correctly as a PING packet.
TEST_P(QuicFramerTest, BuildMtuDiscoveryPacket) { … }

TEST_P(QuicFramerTest, BuildPublicResetPacket) { … }

TEST_P(QuicFramerTest, BuildPublicResetPacketWithClientAddress) { … }

TEST_P(QuicFramerTest, BuildPublicResetPacketWithEndpointId) { … }

TEST_P(QuicFramerTest, BuildIetfStatelessResetPacket) { … }

TEST_P(QuicFramerTest, BuildIetfStatelessResetPacketCallerProvidedRandomBytes) { … }

TEST_P(QuicFramerTest, EncryptPacket) { … }

// Regression test for b/158014497.
TEST_P(QuicFramerTest, EncryptEmptyPacket) { … }

TEST_P(QuicFramerTest, EncryptPacketWithVersionFlag) { … }

TEST_P(QuicFramerTest, AckTruncationLargePacket) { … }

// Regression test for b/150386368.
TEST_P(QuicFramerTest, IetfAckFrameTruncation) { … }

TEST_P(QuicFramerTest, AckTruncationSmallPacket) { … }

TEST_P(QuicFramerTest, CleanTruncation) { … }

TEST_P(QuicFramerTest, StopPacketProcessing) { … }

static char kTestString[] = …;
static QuicStreamId kTestQuicStreamId = …;

MATCHER_P(ExpectedStreamFrame, version, "") { … }

// Verify that the packet returned by ConstructEncryptedPacket() can be properly
// parsed by the framer.
TEST_P(QuicFramerTest, ConstructEncryptedPacket) { … }

// Verify that the packet returned by ConstructMisFramedEncryptedPacket()
// does cause the framer to return an error.
TEST_P(QuicFramerTest, ConstructMisFramedEncryptedPacket) { … }

TEST_P(QuicFramerTest, IetfBlockedFrame) { … }

TEST_P(QuicFramerTest, BuildIetfBlockedPacket) { … }

TEST_P(QuicFramerTest, IetfStreamBlockedFrame) { … }

TEST_P(QuicFramerTest, BuildIetfStreamBlockedPacket) { … }

TEST_P(QuicFramerTest, BiDiMaxStreamsFrame) { … }

TEST_P(QuicFramerTest, UniDiMaxStreamsFrame) { … }

TEST_P(QuicFramerTest, ServerUniDiMaxStreamsFrame) { … }

TEST_P(QuicFramerTest, ClientUniDiMaxStreamsFrame) { … }

// The following four tests ensure that the framer can deserialize a stream
// count that is large enough to cause the resulting stream ID to exceed the
// current implementation limit(32 bits). The intent is that when this happens,
// the stream limit is pegged to the maximum supported value. There are four
// tests, for the four combinations of uni- and bi-directional, server- and
// client- initiated.
TEST_P(QuicFramerTest, BiDiMaxStreamsFrameTooBig) { … }

TEST_P(QuicFramerTest, ClientBiDiMaxStreamsFrameTooBig) { … }

TEST_P(QuicFramerTest, ServerUniDiMaxStreamsFrameTooBig) { … }

TEST_P(QuicFramerTest, ClientUniDiMaxStreamsFrameTooBig) { … }

// Specifically test that count==0 is accepted.
TEST_P(QuicFramerTest, MaxStreamsFrameZeroCount) { … }

TEST_P(QuicFramerTest, ServerBiDiStreamsBlockedFrame) { … }

TEST_P(QuicFramerTest, BiDiStreamsBlockedFrame) { … }

TEST_P(QuicFramerTest, UniDiStreamsBlockedFrame) { … }

TEST_P(QuicFramerTest, ClientUniDiStreamsBlockedFrame) { … }

// Check that when we get a STREAMS_BLOCKED frame that specifies too large
// a stream count, we reject with an appropriate error. There is no need to
// check for different combinations of Uni/Bi directional and client/server
// initiated; the logic does not take these into account.
TEST_P(QuicFramerTest, StreamsBlockedFrameTooBig) { … }

// Specifically test that count==0 is accepted.
TEST_P(QuicFramerTest, StreamsBlockedFrameZeroCount) { … }

TEST_P(QuicFramerTest, BuildBiDiStreamsBlockedPacket) { … }

TEST_P(QuicFramerTest, BuildUniStreamsBlockedPacket) { … }

TEST_P(QuicFramerTest, BuildBiDiMaxStreamsPacket) { … }

TEST_P(QuicFramerTest, BuildUniDiMaxStreamsPacket) { … }

TEST_P(QuicFramerTest, NewConnectionIdFrame) { … }

TEST_P(QuicFramerTest, NewConnectionIdFrameVariableLength) { … }

// Verifies that parsing a NEW_CONNECTION_ID frame with a length above the
// specified maximum fails.
TEST_P(QuicFramerTest, InvalidLongNewConnectionIdFrame) { … }

// Verifies that parsing a NEW_CONNECTION_ID frame with an invalid
// retire-prior-to fails.
TEST_P(QuicFramerTest, InvalidRetirePriorToNewConnectionIdFrame) { … }

TEST_P(QuicFramerTest, BuildNewConnectionIdFramePacket) { … }

TEST_P(QuicFramerTest, NewTokenFrame) { … }

TEST_P(QuicFramerTest, BuildNewTokenFramePacket) { … }

TEST_P(QuicFramerTest, IetfStopSendingFrame) { … }

TEST_P(QuicFramerTest, BuildIetfStopSendingPacket) { … }

TEST_P(QuicFramerTest, IetfPathChallengeFrame) { … }

TEST_P(QuicFramerTest, BuildIetfPathChallengePacket) { … }

TEST_P(QuicFramerTest, IetfPathResponseFrame) { … }

TEST_P(QuicFramerTest, BuildIetfPathResponsePacket) { … }

TEST_P(QuicFramerTest, GetRetransmittableControlFrameSize) { … }

// A set of tests to ensure that bad frame-type encodings
// are properly detected and handled.
// First, four tests to see that unknown frame types generate
// a QUIC_INVALID_FRAME_DATA error with detailed information
// "Illegal frame type." This regardless of the encoding of the type
// (1/2/4/8 bytes).
// This only for version 99.
TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorUnknown1Byte) { … }

TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorUnknown2Bytes) { … }

TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorUnknown4Bytes) { … }

TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorUnknown8Bytes) { … }

// Three tests to check that known frame types that are not minimally
// encoded generate IETF_QUIC_PROTOCOL_VIOLATION errors with detailed
// information "Frame type not minimally encoded."
// Look at the frame-type encoded in 2, 4, and 8 bytes.
TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorKnown2Bytes) { … }

TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorKnown4Bytes) { … }

TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorKnown8Bytes) { … }

// Tests to check that all known IETF frame types that are not minimally
// encoded generate IETF_QUIC_PROTOCOL_VIOLATION errors with detailed
// information "Frame type not minimally encoded."
// Just look at 2-byte encoding.
TEST_P(QuicFramerTest, IetfFrameTypeEncodingErrorKnown2BytesAllTypes) { … }

TEST_P(QuicFramerTest, RetireConnectionIdFrame) { … }

TEST_P(QuicFramerTest, BuildRetireConnectionIdFramePacket) { … }

TEST_P(QuicFramerTest, AckFrameWithInvalidLargestObserved) { … }

TEST_P(QuicFramerTest, FirstAckBlockJustUnderFlow) { … }

TEST_P(QuicFramerTest, ThirdAckBlockJustUnderflow) { … }

TEST_P(QuicFramerTest, CoalescedPacket) { … }

TEST_P(QuicFramerTest, CoalescedPacketWithUdpPadding) { … }

TEST_P(QuicFramerTest, CoalescedPacketWithDifferentVersion) { … }

TEST_P(QuicFramerTest, UndecryptablePacketWithoutDecrypter) { … }

TEST_P(QuicFramerTest, UndecryptablePacketWithDecrypter) { … }

TEST_P(QuicFramerTest, UndecryptableCoalescedPacket) { … }

TEST_P(QuicFramerTest, MismatchedCoalescedPacket) { … }

TEST_P(QuicFramerTest, InvalidCoalescedPacket) { … }

// Some IETF implementations send an initial followed by zeroes instead of
// padding inside the initial. We need to make sure that we still process
// the initial correctly and ignore the zeroes.
TEST_P(QuicFramerTest, CoalescedPacketWithZeroesRoundTrip) { … }

TEST_P(QuicFramerTest, ClientReceivesWrongVersion) { … }

TEST_P(QuicFramerTest, PacketHeaderWithVariableLengthConnectionId) { … }

TEST_P(QuicFramerTest, MultiplePacketNumberSpaces) { … }

TEST_P(QuicFramerTest, IetfRetryPacketRejected) { … }

TEST_P(QuicFramerTest, RetryPacketRejectedWithMultiplePacketNumberSpaces) { … }

TEST_P(QuicFramerTest, WriteClientVersionNegotiationProbePacket) { … }

TEST_P(QuicFramerTest, DispatcherParseOldClientVersionNegotiationProbePacket) { … }

TEST_P(QuicFramerTest, DispatcherParseClientVersionNegotiationProbePacket) { … }

TEST_P(QuicFramerTest, DispatcherParseClientInitialPacketNumber) { … }

TEST_P(QuicFramerTest,
       DispatcherParseClientInitialPacketNumberFromCoalescedPacket) { … }

TEST_P(QuicFramerTest, ParseServerVersionNegotiationProbeResponse) { … }

TEST_P(QuicFramerTest, ParseClientVersionNegotiationProbePacket) { … }

TEST_P(QuicFramerTest, WriteServerVersionNegotiationProbeResponse) { … }

TEST_P(QuicFramerTest, ClientConnectionIdFromLongHeaderToClient) { … }

TEST_P(QuicFramerTest, ClientConnectionIdFromLongHeaderToServer) { … }

TEST_P(QuicFramerTest, ProcessAndValidateIetfConnectionIdLengthClient) { … }

TEST_P(QuicFramerTest, ProcessAndValidateIetfConnectionIdLengthServer) { … }

TEST_P(QuicFramerTest, TestExtendedErrorCodeParser) { … }

// Regression test for crbug/1029636.
TEST_P(QuicFramerTest, OverlyLargeAckDelay) { … }

TEST_P(QuicFramerTest, KeyUpdate) { … }

TEST_P(QuicFramerTest, KeyUpdateOldPacketAfterUpdate) { … }

TEST_P(QuicFramerTest, KeyUpdateOldPacketAfterDiscardPreviousOneRttKeys) { … }

TEST_P(QuicFramerTest, KeyUpdatePacketsOutOfOrder) { … }

TEST_P(QuicFramerTest, KeyUpdateWrongKey) { … }

TEST_P(QuicFramerTest, KeyUpdateReceivedWhenNotEnabled) { … }

TEST_P(QuicFramerTest, KeyUpdateLocallyInitiated) { … }

TEST_P(QuicFramerTest, KeyUpdateLocallyInitiatedReceivedOldPacket) { … }

TEST_P(QuicFramerTest, KeyUpdateOnFirstReceivedPacket) { … }

TEST_P(QuicFramerTest, ErrorWhenUnexpectedFrameTypeEncountered) { … }

TEST_P(QuicFramerTest, ShortHeaderWithNonDefaultConnectionIdLength) { … }

TEST_P(QuicFramerTest, ReportEcnCountsIfPresent) { … }

}  // namespace
}  // namespace test
}  // namespace quic
chromium/net/third_party/quiche/src/quiche/quic/core/quic_framer_test.cc
