[Indeterminate-Length BHTTP] Adding response encoder PiperOrigin-RevId: 793739849
diff --git a/quiche/binary_http/binary_http_message.cc b/quiche/binary_http/binary_http_message.cc index bc7a9b0..5b06bf3 100644 --- a/quiche/binary_http/binary_http_message.cc +++ b/quiche/binary_http/binary_http_message.cc
@@ -5,6 +5,7 @@ #include <functional> #include <iterator> #include <memory> +#include <optional> #include <ostream> #include <string> #include <utility> @@ -19,6 +20,7 @@ #include "absl/strings/str_format.h" #include "absl/strings/str_join.h" #include "absl/strings/string_view.h" +#include "absl/types/span.h" #include "quiche/common/quiche_callbacks.h" #include "quiche/common/quiche_data_reader.h" #include "quiche/common/quiche_data_writer.h" @@ -29,15 +31,9 @@ constexpr uint64_t kKnownLengthRequestFraming = 0; constexpr uint64_t kKnownLengthResponseFraming = 1; constexpr uint64_t kIndeterminateLengthRequestFraming = 2; +constexpr uint64_t kIndeterminateLengthResponseFraming = 3; constexpr uint64_t kContentTerminator = 0; -// A view of a field name and value. Used to pass around a field without owning -// or copying the backing data. -struct FieldView { - absl::string_view name; - absl::string_view value; -}; - bool ReadStringValue(quiche::QuicheDataReader& reader, std::string& data) { absl::string_view data_view; if (!reader.ReadStringPieceVarInt62(&data_view)) { @@ -72,8 +68,8 @@ // Decodes a header/trailer name and value. This takes a length which represents // only the name length. -absl::StatusOr<FieldView> DecodeField(QuicheDataReader& reader, - uint64_t name_length) { +absl::StatusOr<BinaryHttpMessage::FieldView> DecodeField( + QuicheDataReader& reader, uint64_t name_length) { absl::string_view name; if (!reader.ReadStringPiece(&name, name_length)) { return absl::OutOfRangeError("Not enough data to read field name."); @@ -82,7 +78,7 @@ if (!reader.ReadStringPieceVarInt62(&value)) { return absl::OutOfRangeError("Not enough data to read field value."); } - return FieldView{name, value}; + return BinaryHttpMessage::FieldView{name, value}; } absl::Status DecodeFields(quiche::QuicheDataReader& reader, @@ -620,6 +616,191 @@ absl::StrCat("Unsupported framing type ", framing)); } +absl::StatusOr<std::string> +BinaryHttpResponse::IndeterminateLengthEncoder::EncodeFieldSection( + std::optional<uint16_t> status_code, absl::Span<FieldView> fields) { + uint64_t total_length = 0; + if (!framing_indicator_encoded_) { + total_length += quiche::QuicheDataWriter::GetVarInt62Len( + kIndeterminateLengthResponseFraming); + } + if (status_code.has_value()) { + total_length += QuicheDataWriter::GetVarInt62Len(*status_code); + } + for (const auto& field : fields) { + uint8_t length = QuicheDataWriter::GetVarInt62Len(field.name.size()); + if (length == 0) { + return absl::InvalidArgumentError("Field name exceeds maximum length."); + } + total_length += length + field.name.size(); + + length = QuicheDataWriter::GetVarInt62Len(field.value.size()); + if (length == 0) { + return absl::InvalidArgumentError("Field value exceeds maximum length."); + } + total_length += length + field.value.size(); + } + total_length += quiche::QuicheDataWriter::GetVarInt62Len(kContentTerminator); + + std::string data(total_length, '\0'); + QuicheDataWriter writer(total_length, data.data()); + + if (!framing_indicator_encoded_) { + if (!writer.WriteVarInt62(kIndeterminateLengthResponseFraming)) { + return absl::InternalError("Failed to write framing indicator."); + } + framing_indicator_encoded_ = true; + } + if (status_code.has_value() && !writer.WriteVarInt62(*status_code)) { + return absl::InternalError("Failed to write status code."); + } + for (const auto& field : fields) { + if (!writer.WriteStringPieceVarInt62(absl::AsciiStrToLower(field.name))) { + return absl::InternalError("Failed to write field name."); + } + if (!writer.WriteStringPieceVarInt62(field.value)) { + return absl::InternalError("Failed to write field value."); + } + } + if (!writer.WriteVarInt62(kContentTerminator)) { + return absl::InternalError("Failed to write content terminator."); + } + if (writer.remaining() != 0) { + return absl::InternalError("Failed to write all data."); + } + return data; +} + +std::string +BinaryHttpResponse::IndeterminateLengthEncoder::GetMessageSectionString( + MessageSection section) const { + switch (section) { + case MessageSection::kInformationalResponseOrHeader: + return "InformationalResponseOrHeader"; + case MessageSection::kBody: + return "Body"; + case MessageSection::kTrailer: + return "Trailer"; + case MessageSection::kEnd: + return "End"; + default: + return "Unknown"; + } +} + +absl::StatusOr<std::string> +BinaryHttpResponse::IndeterminateLengthEncoder::EncodeInformationalResponse( + uint16_t status_code, absl::Span<FieldView> fields) { + if (current_section_ != MessageSection::kInformationalResponseOrHeader) { + current_section_ = MessageSection::kEnd; + return absl::InvalidArgumentError(absl::StrCat( + "EncodeInformationalResponse called in incorrect section: ", + GetMessageSectionString(current_section_))); + } + if (status_code < 100 || status_code > 199) { + current_section_ = MessageSection::kEnd; + return absl::InvalidArgumentError(absl::StrCat( + "Invalid informational response status code: ", status_code)); + } + + absl::StatusOr<std::string> data = EncodeFieldSection(status_code, fields); + if (!data.ok()) { + current_section_ = MessageSection::kEnd; + } + + return data; +} + +absl::StatusOr<std::string> +BinaryHttpResponse::IndeterminateLengthEncoder::EncodeHeaders( + uint16_t status_code, absl::Span<FieldView> headers) { + if (current_section_ != MessageSection::kInformationalResponseOrHeader) { + current_section_ = MessageSection::kEnd; + return absl::InvalidArgumentError( + absl::StrCat("EncodeHeaders called in incorrect section: ", + GetMessageSectionString(current_section_))); + } + if (status_code < 200 || status_code > 599) { + current_section_ = MessageSection::kEnd; + return absl::InvalidArgumentError( + absl::StrCat("Invalid response status code: ", status_code)); + } + + absl::StatusOr<std::string> data = EncodeFieldSection(status_code, headers); + if (!data.ok()) { + current_section_ = MessageSection::kEnd; + return data; + } + current_section_ = MessageSection::kBody; + return data; +} + +absl::StatusOr<std::string> +BinaryHttpResponse::IndeterminateLengthEncoder::EncodeBodyChunks( + absl::Span<absl::string_view> body_chunks, bool body_chunks_done) { + if (current_section_ != MessageSection::kBody) { + current_section_ = MessageSection::kEnd; + return absl::InvalidArgumentError( + absl::StrCat("EncodeBodyChunks called in incorrect section: ", + GetMessageSectionString(current_section_))); + } + uint64_t total_length = 0; + for (const auto& body_chunk : body_chunks) { + uint8_t body_chunk_var_int_length = + QuicheDataWriter::GetVarInt62Len(body_chunk.size()); + if (body_chunk_var_int_length == 0) { + current_section_ = MessageSection::kEnd; + return absl::InvalidArgumentError( + "Body chunk size exceeds maximum length."); + } + total_length += body_chunk_var_int_length + body_chunk.size(); + } + if (body_chunks_done) { + total_length += + quiche::QuicheDataWriter::GetVarInt62Len(kContentTerminator); + } + + std::string data(total_length, '\0'); + QuicheDataWriter writer(total_length, data.data()); + + for (const auto& body_chunk : body_chunks) { + if (!writer.WriteStringPieceVarInt62(body_chunk)) { + current_section_ = MessageSection::kEnd; + return absl::InternalError("Failed to write body chunk."); + } + } + if (body_chunks_done) { + if (!writer.WriteVarInt62(kContentTerminator)) { + current_section_ = MessageSection::kEnd; + return absl::InternalError("Failed to write content terminator."); + } + current_section_ = MessageSection::kTrailer; + } + + if (writer.remaining() != 0) { + current_section_ = MessageSection::kEnd; + return absl::InternalError("Failed to write all data."); + } + return data; +} + +absl::StatusOr<std::string> +BinaryHttpResponse::IndeterminateLengthEncoder::EncodeTrailers( + absl::Span<FieldView> trailers) { + if (current_section_ != MessageSection::kTrailer) { + current_section_ = MessageSection::kEnd; + return absl::InvalidArgumentError( + absl::StrCat("EncodeTrailers called in incorrect section: ", + GetMessageSectionString(current_section_))); + } + + absl::StatusOr<std::string> data = + EncodeFieldSection(/*status_code=*/std::nullopt, trailers); + + current_section_ = MessageSection::kEnd; + return data; +} + std::string BinaryHttpMessage::DebugString() const { std::vector<std::string> headers; for (const auto& field : GetHeaderFields()) {
diff --git a/quiche/binary_http/binary_http_message.h b/quiche/binary_http/binary_http_message.h index 0a28e0a..41a6bc1 100644 --- a/quiche/binary_http/binary_http_message.h +++ b/quiche/binary_http/binary_http_message.h
@@ -5,6 +5,7 @@ #include <cstdint> #include <functional> #include <memory> +#include <optional> #include <ostream> #include <string> #include <utility> @@ -14,6 +15,7 @@ #include "absl/status/status.h" #include "absl/status/statusor.h" #include "absl/strings/string_view.h" +#include "absl/types/span.h" #include "quiche/common/platform/api/quiche_export.h" #include "quiche/common/quiche_data_reader.h" #include "quiche/common/quiche_data_writer.h" @@ -25,6 +27,12 @@ // https://www.ietf.org/archive/id/draft-ietf-httpbis-binary-message-06.html class QUICHE_EXPORT BinaryHttpMessage { public: + // A view of a field name and value. Used to pass around a field without + // owning or copying the backing data. + struct QUICHE_EXPORT FieldView { + absl::string_view name; + absl::string_view value; + }; // Name value pair of either a header or trailer field. struct QUICHE_EXPORT Field { std::string name; @@ -364,6 +372,42 @@ return !(*this == rhs); } + // Provides encoding methods for an Indeterminate-Length BHTTP response. The + // encoder keeps track of what has been encoded so far to ensure sections are + // encoded in the correct order, this means it can only be used for a single + // BHTTP response message. + class QUICHE_EXPORT IndeterminateLengthEncoder { + public: + // Encodes the specified informational response status code, fields, and its + // content terminator. + absl::StatusOr<std::string> EncodeInformationalResponse( + uint16_t status_code, absl::Span<FieldView> fields); + // Encodes the specified status code, headers, and its content terminator. + absl::StatusOr<std::string> EncodeHeaders(uint16_t status_code, + absl::Span<FieldView> headers); + // Encodes the specified body chunks. If 'body_chunks_done' is true, the + // encoded body chunks are followed by the content terminator. + absl::StatusOr<std::string> EncodeBodyChunks( + absl::Span<absl::string_view> body_chunks, bool body_chunks_done); + // Encodes the specified trailers and its content terminator. + absl::StatusOr<std::string> EncodeTrailers(absl::Span<FieldView> trailers); + + private: + enum class MessageSection { + kInformationalResponseOrHeader, + kBody, + kTrailer, + kEnd, + }; + absl::StatusOr<std::string> EncodeFieldSection( + std::optional<uint16_t> status_code, absl::Span<FieldView> fields); + std::string GetMessageSectionString(MessageSection section) const; + + MessageSection current_section_ = + MessageSection::kInformationalResponseOrHeader; + bool framing_indicator_encoded_ = false; + }; + private: // Returns Binary Http known length request formatted response. absl::StatusOr<std::string> EncodeAsKnownLength() const;
diff --git a/quiche/binary_http/binary_http_message_test.cc b/quiche/binary_http/binary_http_message_test.cc index 0a6e3d8..d267d9e 100644 --- a/quiche/binary_http/binary_http_message_test.cc +++ b/quiche/binary_http/binary_http_message_test.cc
@@ -10,9 +10,11 @@ #include "absl/container/flat_hash_map.h" #include "absl/status/status.h" +#include "absl/status/statusor.h" #include "absl/strings/escaping.h" #include "absl/strings/str_cat.h" #include "absl/strings/string_view.h" +#include "absl/types/span.h" #include "quiche/common/platform/api/quiche_test.h" #include "quiche/common/test_tools/quiche_test_utils.h" @@ -586,6 +588,274 @@ ExpectTruncatedTrailerSection(message_data); } +namespace { + +struct ResponseIndeterminateLengthEncoderTestData { + std::vector<quiche::BinaryHttpMessage::FieldView> informationalResponse1{ + {"running", "\"sleep 15\""}}; + std::vector<BinaryHttpMessage::FieldView> informationalResponse2{ + {/*uppercase*/ "LINK", "</style.css>; rel=preload; as=style"}, + {"link", "</script.js>; rel=preload; as=script"}, + {"longer_header_value", + "1111111111111111111111111111111111111111111111111111111111111111"}}; + std::vector<BinaryHttpMessage::FieldView> headers{ + {"Date", "Mon, 27 Jul 2009 12:28:53 GMT"}, + {"Server", "Apache"}, + {"longer_header_value", + "1111111111111111111111111111111111111111111111111111111111111111"}}; + std::vector<absl::string_view> body_chunks = { + "chunk1", "chunk2", "chunk3", + "1111111111111111111111111111111111111111111111111111111111111111"}; + std::vector<BinaryHttpMessage::FieldView> trailers{ + {"trailer1", "value1"}, + {"trailer2", "value2"}, + {"longer_trailer_value", + "1111111111111111111111111111111111111111111111111111111111111111"}}; +}; + +constexpr absl::string_view kEncodedInformationalResponses = + "4066" // status code: 102 + "0772756e6e696e67" // running + "0a22736C65657020313522" // "sleep 15" + "00" // content terminator + "4067" // status code: 103 + "046C696E6B" // link + "233C2F7374796C652E6373733E3B2072656C3D7072656C6F6" + "1643B2061733D737479" + "6C65" // </style.css>; rel=preload; as=style + "046C696E6B" // link + "243C2F7363726970742E6A733E3B2072656C3D7072656C6F6" + "1643B2061733D736372" + "697074" // </script.js>; rel=preload; as=script + "136C6F6E6765725F6865616465725F76616C7565" // longer_header_value + "40403131313131313131313131313131313131313131313131313131313131313131313131" + "3131313131313131313131313131313131313131313131313131313131" // 64 1s + "00"; // content terminator + +constexpr absl::string_view kEncodedResponse = + "40C8" // status code: 200 + "0464617465" // date + "1D4D6F6E2C203237204A756C20323030392031323A32383A3" + "53320474D54" // Mon, 27 + // Jul + // 2009 + // 12:28:53 + // GMT + "06736572766572" // server + "06417061636865" // Apache + "136C6F6E6765725F6865616465725F76616C7565" // longer_header_value + "40403131313131313131313131313131313131313131313131313131313131313131313131" + "3131313131313131313131313131313131313131313131313131313131" // 64 1s + "00" // content terminator + "066368756E6B31" // chunk1 + "066368756E6B32" // chunk2 + "066368756E6B33" // chunk3 + "40403131313131313131313131313131313131313131313131313131313131313131313131" + "3131313131313131313131313131313131313131313131313131313131" // 64 1s + "00" // content terminator + "08747261696C657231" // trailer1 + "0676616C756531" // value1 + "08747261696C657232" // trailer2 + "0676616C756532" // value2 + "146C6F6E6765725F747261696C65725F76616C7565" // longer_trailer_value + "40403131313131313131313131313131313131313131313131313131313131313131313131" + "3131313131313131313131313131313131313131313131313131313131" // 64 1s + "00"; + +} // namespace + +TEST(ResponseIndeterminateLengthEncoder, WithInformationalResponses) { + std::string expected; + ASSERT_TRUE(absl::HexStringToBytes( + absl::StrCat("03", kEncodedInformationalResponses, kEncodedResponse), + &expected)); + + BinaryHttpResponse::IndeterminateLengthEncoder encoder; + ResponseIndeterminateLengthEncoderTestData test_data; + std::string encoded_data; + + absl::StatusOr<std::string> status_or_encoded_data = + encoder.EncodeInformationalResponse( + 102, absl::MakeSpan(test_data.informationalResponse1)); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + status_or_encoded_data = encoder.EncodeInformationalResponse( + 103, absl::MakeSpan(test_data.informationalResponse2)); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + + status_or_encoded_data = + encoder.EncodeHeaders(200, absl::MakeSpan(test_data.headers)); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + + status_or_encoded_data = + encoder.EncodeBodyChunks(absl::MakeSpan(test_data.body_chunks), true); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + + status_or_encoded_data = + encoder.EncodeTrailers(absl::MakeSpan(test_data.trailers)); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + + EXPECT_EQ(encoded_data, expected); +} + +TEST(ResponseIndeterminateLengthEncoder, NoInformationalResponses) { + std::string expected; + ASSERT_TRUE( + absl::HexStringToBytes(absl::StrCat("03", kEncodedResponse), &expected)); + + BinaryHttpResponse::IndeterminateLengthEncoder encoder; + ResponseIndeterminateLengthEncoderTestData test_data; + std::string encoded_data; + + absl::StatusOr<std::string> status_or_encoded_data = + encoder.EncodeHeaders(200, absl::MakeSpan(test_data.headers)); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + + status_or_encoded_data = + encoder.EncodeBodyChunks(absl::MakeSpan(test_data.body_chunks), true); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + + status_or_encoded_data = + encoder.EncodeTrailers(absl::MakeSpan(test_data.trailers)); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + + EXPECT_EQ(encoded_data, expected); +} + +TEST(ResponseIndeterminateLengthEncoder, EncodingChunksMultipleTimes) { + std::string expected; + ASSERT_TRUE( + absl::HexStringToBytes(absl::StrCat("03", kEncodedResponse), &expected)); + + BinaryHttpResponse::IndeterminateLengthEncoder encoder; + ResponseIndeterminateLengthEncoderTestData test_data; + std::string encoded_data; + + absl::StatusOr<std::string> status_or_encoded_data = + encoder.EncodeHeaders(200, absl::MakeSpan(test_data.headers)); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + + status_or_encoded_data = encoder.EncodeBodyChunks( + absl::MakeSpan(test_data.body_chunks.data(), 1), false); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + status_or_encoded_data = encoder.EncodeBodyChunks( + absl::MakeSpan(test_data.body_chunks.data() + 1, 1), false); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + status_or_encoded_data = encoder.EncodeBodyChunks( + absl::MakeSpan(test_data.body_chunks.data() + 2, 1), false); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + status_or_encoded_data = encoder.EncodeBodyChunks( + absl::MakeSpan(test_data.body_chunks.data() + 3, 1), false); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + status_or_encoded_data = encoder.EncodeBodyChunks({}, true); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + + status_or_encoded_data = + encoder.EncodeTrailers(absl::MakeSpan(test_data.trailers)); + QUICHE_EXPECT_OK(status_or_encoded_data); + encoded_data += *status_or_encoded_data; + EXPECT_EQ(encoded_data, expected); +} + +TEST(ResponseIndeterminateLengthEncoder, EncodingWrongStatusCodes) { + BinaryHttpResponse::IndeterminateLengthEncoder encoder; + absl::StatusOr<std::string> status_or_encoded_data = + encoder.EncodeInformationalResponse(99, {}); + EXPECT_THAT(status_or_encoded_data, + test::StatusIs(absl::StatusCode::kInvalidArgument)); + + encoder = BinaryHttpResponse::IndeterminateLengthEncoder(); + status_or_encoded_data = encoder.EncodeInformationalResponse(200, {}); + EXPECT_THAT(status_or_encoded_data, + test::StatusIs(absl::StatusCode::kInvalidArgument)); + + encoder = BinaryHttpResponse::IndeterminateLengthEncoder(); + status_or_encoded_data = encoder.EncodeHeaders(199, {}); + EXPECT_THAT(status_or_encoded_data, + test::StatusIs(absl::StatusCode::kInvalidArgument)); + + encoder = BinaryHttpResponse::IndeterminateLengthEncoder(); + status_or_encoded_data = encoder.EncodeHeaders(600, {}); + EXPECT_THAT(status_or_encoded_data, + test::StatusIs(absl::StatusCode::kInvalidArgument)); +} + +TEST(ResponseIndeterminateLengthEncoder, OutOfOrderBodyChunks) { + BinaryHttpResponse::IndeterminateLengthEncoder encoder; + absl::StatusOr<std::string> status_or_encoded_data = + encoder.EncodeBodyChunks({}, true); + EXPECT_THAT(status_or_encoded_data, + test::StatusIs(absl::StatusCode::kInvalidArgument)); +} + +TEST(ResponseIndeterminateLengthEncoder, OutOfOrderTrailers) { + BinaryHttpResponse::IndeterminateLengthEncoder encoder; + absl::StatusOr<std::string> status_or_encoded_data = + encoder.EncodeTrailers({}); + EXPECT_THAT(status_or_encoded_data, + test::StatusIs(absl::StatusCode::kInvalidArgument)); +} + +TEST(ResponseIndeterminateLengthEncoder, OutOfOrderInformationalResponse) { + // Cannot encode informational responses after headers. + BinaryHttpResponse::IndeterminateLengthEncoder encoder; + absl::StatusOr<std::string> status_or_encoded_data = + encoder.EncodeHeaders(200, {}); + QUICHE_EXPECT_OK(status_or_encoded_data); + status_or_encoded_data = encoder.EncodeInformationalResponse(102, {}); + EXPECT_THAT(status_or_encoded_data, + test::StatusIs(absl::StatusCode::kInvalidArgument)); +} + +TEST(ResponseIndeterminateLengthEncoder, MustNotEncodeChunksAfterChunksDone) { + BinaryHttpResponse::IndeterminateLengthEncoder encoder; + absl::StatusOr<std::string> status_or_encoded_data = + encoder.EncodeHeaders(200, {}); + QUICHE_EXPECT_OK(status_or_encoded_data); + status_or_encoded_data = encoder.EncodeBodyChunks({}, true); + QUICHE_EXPECT_OK(status_or_encoded_data); + status_or_encoded_data = encoder.EncodeBodyChunks({}, true); + EXPECT_THAT(status_or_encoded_data, + test::StatusIs(absl::StatusCode::kInvalidArgument)); +} + +TEST(ResponseIndeterminateLengthEncoder, MustNotEncodeHeadersTwice) { + BinaryHttpResponse::IndeterminateLengthEncoder encoder; + absl::StatusOr<std::string> status_or_encoded_data = + encoder.EncodeHeaders(200, {}); + QUICHE_EXPECT_OK(status_or_encoded_data); + status_or_encoded_data = encoder.EncodeHeaders(200, {}); + EXPECT_THAT(status_or_encoded_data, + test::StatusIs(absl::StatusCode::kInvalidArgument)); +} + +TEST(ResponseIndeterminateLengthEncoder, MustNotEncodeTrailersTwice) { + BinaryHttpResponse::IndeterminateLengthEncoder encoder; + absl::StatusOr<std::string> status_or_encoded_data = + encoder.EncodeHeaders(200, {}); + QUICHE_EXPECT_OK(status_or_encoded_data); + status_or_encoded_data = encoder.EncodeBodyChunks({}, true); + QUICHE_EXPECT_OK(status_or_encoded_data); + status_or_encoded_data = encoder.EncodeTrailers({}); + QUICHE_EXPECT_OK(status_or_encoded_data); + status_or_encoded_data = encoder.EncodeTrailers({}); + EXPECT_THAT(status_or_encoded_data, + test::StatusIs(absl::StatusCode::kInvalidArgument)); +} + TEST(IndeterminateLengthDecoder, TruncatedTrailers) { RequestMessageSectionTestHandler handler; BinaryHttpRequest::IndeterminateLengthDecoder decoder(handler);