diff --git a/quiche/common/wire_serialization_test.cc b/quiche/common/wire_serialization_test.cc
new file mode 100644
index 0000000..b1dea91
--- /dev/null
+++ b/quiche/common/wire_serialization_test.cc
@@ -0,0 +1,256 @@
+// 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 "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.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) {
+  absl::optional<uint8_t> has_no_value;
+  absl::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));
+
+  absl::optional<std::string> has_no_string;
+  absl::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
+}
+
+}  // namespace
+}  // namespace quiche::test