blob: 6c8267fafaffc4e7d9b980f0127e5914516bbb7b [file] [log] [blame]
// Copyright (c) 2022 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/common/wire_serialization.h"
#include <limits>
#include <optional>
#include "absl/status/status.h"
#include "absl/status/statusor.h"
#include "absl/strings/escaping.h"
#include "absl/strings/string_view.h"
#include "quiche/common/platform/api/quiche_expect_bug.h"
#include "quiche/common/platform/api/quiche_test.h"
#include "quiche/common/quiche_buffer_allocator.h"
#include "quiche/common/quiche_endian.h"
#include "quiche/common/quiche_status_utils.h"
#include "quiche/common/simple_buffer_allocator.h"
#include "quiche/common/test_tools/quiche_test_utils.h"
namespace quiche::test {
namespace {
using ::testing::ElementsAre;
constexpr uint64_t kInvalidVarInt = std::numeric_limits<uint64_t>::max();
template <typename... Ts>
absl::StatusOr<quiche::QuicheBuffer> SerializeIntoSimpleBuffer(Ts... data) {
return SerializeIntoBuffer(quiche::SimpleBufferAllocator::Get(), data...);
}
template <typename... Ts>
void ExpectEncoding(const std::string& description, absl::string_view expected,
Ts... data) {
absl::StatusOr<quiche::QuicheBuffer> actual =
SerializeIntoSimpleBuffer(data...);
QUICHE_ASSERT_OK(actual);
quiche::test::CompareCharArraysWithHexError(description, actual->data(),
actual->size(), expected.data(),
expected.size());
}
template <typename... Ts>
void ExpectEncodingHex(const std::string& description,
absl::string_view expected_hex, Ts... data) {
ExpectEncoding(description, absl::HexStringToBytes(expected_hex), data...);
}
TEST(SerializationTest, SerializeStrings) {
absl::StatusOr<quiche::QuicheBuffer> one_string =
SerializeIntoSimpleBuffer(WireBytes("test"));
QUICHE_ASSERT_OK(one_string);
EXPECT_EQ(one_string->AsStringView(), "test");
absl::StatusOr<quiche::QuicheBuffer> two_strings =
SerializeIntoSimpleBuffer(WireBytes("Hello"), WireBytes("World"));
QUICHE_ASSERT_OK(two_strings);
EXPECT_EQ(two_strings->AsStringView(), "HelloWorld");
}
TEST(SerializationTest, SerializeIntegers) {
ExpectEncodingHex("one uint8_t value", "42", WireUint8(0x42));
ExpectEncodingHex("two uint8_t values", "ab01", WireUint8(0xab),
WireUint8(0x01));
ExpectEncodingHex("one uint16_t value", "1234", WireUint16(0x1234));
ExpectEncodingHex("one uint32_t value", "12345678", WireUint32(0x12345678));
ExpectEncodingHex("one uint64_t value", "123456789abcdef0",
WireUint64(UINT64_C(0x123456789abcdef0)));
ExpectEncodingHex("mix of values", "aabbcc000000dd", WireUint8(0xaa),
WireUint16(0xbbcc), WireUint32(0xdd));
}
TEST(SerializationTest, SerializeLittleEndian) {
char buffer[4];
QuicheDataWriter writer(sizeof(buffer), buffer,
quiche::Endianness::HOST_BYTE_ORDER);
QUICHE_ASSERT_OK(
SerializeIntoWriter(writer, WireUint16(0x1234), WireUint16(0xabcd)));
absl::string_view actual(writer.data(), writer.length());
EXPECT_EQ(actual, absl::HexStringToBytes("3412cdab"));
}
TEST(SerializationTest, SerializeVarInt62) {
// Test cases from RFC 9000, Appendix A.1
ExpectEncodingHex("1-byte varint", "25", WireVarInt62(37));
ExpectEncodingHex("2-byte varint", "7bbd", WireVarInt62(15293));
ExpectEncodingHex("4-byte varint", "9d7f3e7d", WireVarInt62(494878333));
ExpectEncodingHex("8-byte varint", "c2197c5eff14e88c",
WireVarInt62(UINT64_C(151288809941952652)));
}
TEST(SerializationTest, SerializeStringWithVarInt62Length) {
ExpectEncodingHex("short string", "0474657374",
WireStringWithVarInt62Length("test"));
const std::string long_string(15293, 'a');
ExpectEncoding("long string", absl::StrCat("\x7b\xbd", long_string),
WireStringWithVarInt62Length(long_string));
ExpectEncodingHex("empty string", "00", WireStringWithVarInt62Length(""));
}
TEST(SerializationTest, SerializeOptionalValues) {
std::optional<uint8_t> has_no_value;
std::optional<uint8_t> has_value = 0x42;
ExpectEncodingHex("optional without value", "00", WireUint8(0),
WireOptional<WireUint8>(has_no_value));
ExpectEncodingHex("optional with value", "0142", WireUint8(1),
WireOptional<WireUint8>(has_value));
ExpectEncodingHex("empty data", "", WireOptional<WireUint8>(has_no_value));
std::optional<std::string> has_no_string;
std::optional<std::string> has_string = "\x42";
ExpectEncodingHex("optional no string", "",
WireOptional<WireStringWithVarInt62Length>(has_no_string));
ExpectEncodingHex("optional string", "0142",
WireOptional<WireStringWithVarInt62Length>(has_string));
}
enum class TestEnum {
kValue1 = 0x17,
kValue2 = 0x19,
};
TEST(SerializationTest, SerializeEnumValue) {
ExpectEncodingHex("enum value", "17", WireVarInt62(TestEnum::kValue1));
}
TEST(SerializationTest, SerializeLotsOfValues) {
ExpectEncodingHex("ten values", "00010203040506070809", WireUint8(0),
WireUint8(1), WireUint8(2), WireUint8(3), WireUint8(4),
WireUint8(5), WireUint8(6), WireUint8(7), WireUint8(8),
WireUint8(9));
}
TEST(SerializationTest, FailDueToLackOfSpace) {
char buffer[4];
QuicheDataWriter writer(sizeof(buffer), buffer);
QUICHE_EXPECT_OK(SerializeIntoWriter(writer, WireUint32(0)));
ASSERT_EQ(writer.remaining(), 0u);
EXPECT_THAT(
SerializeIntoWriter(writer, WireUint32(0)),
StatusIs(absl::StatusCode::kInternal, "Failed to serialize field #0"));
EXPECT_THAT(
SerializeIntoWriter(writer, WireStringWithVarInt62Length("test")),
StatusIs(
absl::StatusCode::kInternal,
"Failed to serialize the length prefix while serializing field #0"));
}
TEST(SerializationTest, FailDueToInvalidValue) {
EXPECT_QUICHE_BUG(
ExpectEncoding("invalid varint", "", WireVarInt62(kInvalidVarInt)),
"too big for VarInt62");
}
TEST(SerializationTest, InvalidValueCausesPartialWrite) {
char buffer[3] = {'\0'};
QuicheDataWriter writer(sizeof(buffer), buffer);
QUICHE_EXPECT_OK(SerializeIntoWriter(writer, WireBytes("a")));
EXPECT_THAT(
SerializeIntoWriter(writer, WireBytes("b"),
WireBytes("A considerably long string, writing which "
"will most likely cause ASAN to crash"),
WireBytes("c")),
StatusIs(absl::StatusCode::kInternal, "Failed to serialize field #1"));
EXPECT_THAT(buffer, ElementsAre('a', 'b', '\0'));
QUICHE_EXPECT_OK(SerializeIntoWriter(writer, WireBytes("z")));
EXPECT_EQ(buffer[2], 'z');
}
TEST(SerializationTest, SerializeVector) {
std::vector<absl::string_view> strs = {"foo", "test", "bar"};
absl::StatusOr<quiche::QuicheBuffer> serialized =
SerializeIntoSimpleBuffer(WireSpan<WireBytes>(absl::MakeSpan(strs)));
QUICHE_ASSERT_OK(serialized);
EXPECT_EQ(serialized->AsStringView(), "footestbar");
}
struct AwesomeStruct {
uint64_t awesome_number;
std::string awesome_text;
};
class WireAwesomeStruct {
public:
using DataType = AwesomeStruct;
WireAwesomeStruct(const AwesomeStruct& awesome) : awesome_(awesome) {}
size_t GetLengthOnWire() {
return quiche::ComputeLengthOnWire(WireUint16(awesome_.awesome_number),
WireBytes(awesome_.awesome_text));
}
absl::Status SerializeIntoWriter(QuicheDataWriter& writer) {
return AppendToStatus(::quiche::SerializeIntoWriter(
writer, WireUint16(awesome_.awesome_number),
WireBytes(awesome_.awesome_text)),
" while serializing AwesomeStruct");
}
private:
const AwesomeStruct& awesome_;
};
TEST(SerializationTest, CustomStruct) {
AwesomeStruct awesome;
awesome.awesome_number = 0xabcd;
awesome.awesome_text = "test";
ExpectEncodingHex("struct", "abcd74657374", WireAwesomeStruct(awesome));
}
TEST(SerializationTest, CustomStructSpan) {
std::array<AwesomeStruct, 2> awesome;
awesome[0].awesome_number = 0xabcd;
awesome[0].awesome_text = "test";
awesome[1].awesome_number = 0x1234;
awesome[1].awesome_text = std::string(3, '\0');
ExpectEncodingHex("struct", "abcd746573741234000000",
WireSpan<WireAwesomeStruct>(absl::MakeSpan(awesome)));
}
class WireFormatterThatWritesTooLittle {
public:
using DataType = absl::string_view;
explicit WireFormatterThatWritesTooLittle(absl::string_view s) : s_(s) {}
size_t GetLengthOnWire() const { return s_.size(); }
bool SerializeIntoWriter(QuicheDataWriter& writer) {
return writer.WriteStringPiece(s_.substr(0, s_.size() - 1));
}
private:
absl::string_view s_;
};
TEST(SerializationTest, CustomStructWritesTooLittle) {
constexpr absl::string_view kStr = "\xaa\xbb\xcc\xdd";
#if defined(NDEBUG)
absl::Status status =
SerializeIntoSimpleBuffer(WireFormatterThatWritesTooLittle(kStr))
.status();
EXPECT_THAT(status, StatusIs(absl::StatusCode::kInternal,
::testing::HasSubstr("Excess 1 bytes")));
#else
EXPECT_DEATH(QUICHE_LOG(INFO) << SerializeIntoSimpleBuffer(
WireFormatterThatWritesTooLittle(kStr))
.status(),
"while serializing field #0");
#endif
}
TEST(SerializationTest, Empty) { ExpectEncodingHex("nothing", ""); }
} // namespace
} // namespace quiche::test