diff --git a/build/source_list.bzl b/build/source_list.bzl
index 9ca439c..c9c0224 100644
--- a/build/source_list.bzl
+++ b/build/source_list.bzl
@@ -1476,8 +1476,14 @@
     "quic/load_balancer/load_balancer_server_id_test.cc",
 ]
 moqt_hdrs = [
+    "quic/moqt/moqt_messages.h",
+    "quic/moqt/moqt_parser.h",
+    "quic/moqt/test_tools/moqt_test_message.h",
 ]
 moqt_srcs = [
+    "quic/moqt/moqt_messages.cc",
+    "quic/moqt/moqt_parser.cc",
+    "quic/moqt/moqt_parser_test.cc",
 ]
 binary_http_hdrs = [
     "binary_http/binary_http_message.h",
diff --git a/build/source_list.gni b/build/source_list.gni
index d8978d9..e70f003 100644
--- a/build/source_list.gni
+++ b/build/source_list.gni
@@ -1480,10 +1480,14 @@
     "src/quiche/quic/load_balancer/load_balancer_server_id_test.cc",
 ]
 moqt_hdrs = [
-
+    "src/quiche/quic/moqt/moqt_messages.h",
+    "src/quiche/quic/moqt/moqt_parser.h",
+    "src/quiche/quic/moqt/test_tools/moqt_test_message.h",
 ]
 moqt_srcs = [
-
+    "src/quiche/quic/moqt/moqt_messages.cc",
+    "src/quiche/quic/moqt/moqt_parser.cc",
+    "src/quiche/quic/moqt/moqt_parser_test.cc",
 ]
 binary_http_hdrs = [
     "src/quiche/binary_http/binary_http_message.h",
diff --git a/build/source_list.json b/build/source_list.json
index 6dbfde3..07bf1a6 100644
--- a/build/source_list.json
+++ b/build/source_list.json
@@ -1479,10 +1479,14 @@
     "quiche/quic/load_balancer/load_balancer_server_id_test.cc"
   ],
   "moqt_hdrs": [
-
+    "quiche/quic/moqt/moqt_messages.h",
+    "quiche/quic/moqt/moqt_parser.h",
+    "quiche/quic/moqt/test_tools/moqt_test_message.h"
   ],
   "moqt_srcs": [
-
+    "quiche/quic/moqt/moqt_messages.cc",
+    "quiche/quic/moqt/moqt_parser.cc",
+    "quiche/quic/moqt/moqt_parser_test.cc"
   ],
   "binary_http_hdrs": [
     "quiche/binary_http/binary_http_message.h"
diff --git a/quiche/quic/moqt/moqt_messages.cc b/quiche/quic/moqt/moqt_messages.cc
new file mode 100644
index 0000000..9b37dc7
--- /dev/null
+++ b/quiche/quic/moqt/moqt_messages.cc
@@ -0,0 +1,34 @@
+// Copyright (c) 2023 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/moqt/moqt_messages.h"
+
+#include <string>
+
+namespace moqt {
+
+std::string MoqtMessageTypeToString(const MoqtMessageType message_type) {
+  switch (message_type) {
+    case MoqtMessageType::kObject:
+      return "OBJECT";
+    case MoqtMessageType::kSetup:
+      return "SETUP";
+    case MoqtMessageType::kSubscribeRequest:
+      return "SUBSCRIBE_REQUEST";
+    case MoqtMessageType::kSubscribeOk:
+      return "SUBSCRIBE_OK";
+    case MoqtMessageType::kSubscribeError:
+      return "SUBSCRIBE_ERROR";
+    case MoqtMessageType::kAnnounce:
+      return "ANNOUNCE";
+    case MoqtMessageType::kAnnounceOk:
+      return "ANNOUNCE_OK";
+    case MoqtMessageType::kAnnounceError:
+      return "ANNOUNCE_ERROR";
+    case MoqtMessageType::kGoAway:
+      return "GOAWAY";
+  }
+}
+
+}  // namespace moqt
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
new file mode 100644
index 0000000..30c1d97
--- /dev/null
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -0,0 +1,112 @@
+// Copyright (c) 2023 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.
+
+// Structured data for message types in draft-ietf-moq-transport-00.
+
+#ifndef QUICHE_QUIC_MOQT_MOQT_MESSAGES_H_
+#define QUICHE_QUIC_MOQT_MOQT_MESSAGES_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "quiche/quic/core/quic_time.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace moqt {
+
+// The maximum length of a message, excluding any OBJECT payload. This prevents
+// DoS attack via forcing the parser to buffer a large message (OBJECT payloads
+// are not buffered by the parser).
+inline constexpr size_t kMaxMessageHeaderSize = 4096;
+
+enum class QUICHE_EXPORT MoqtMessageType : uint64_t {
+  kObject = 0x00,
+  kSetup = 0x01,
+  kSubscribeRequest = 0x03,
+  kSubscribeOk = 0x04,
+  kSubscribeError = 0x05,
+  kAnnounce = 0x06,
+  kAnnounceOk = 0x7,
+  kAnnounceError = 0x08,
+  kGoAway = 0x10,
+};
+
+enum class QUICHE_EXPORT MoqtRole : uint64_t {
+  kIngestion = 0x1,
+  kDelivery = 0x2,
+  kBoth = 0x3,
+};
+
+enum class QUICHE_EXPORT MoqtSetupParameter : uint64_t {
+  kRole = 0x0,
+  kPath = 0x1,
+};
+
+enum class QUICHE_EXPORT MoqtTrackRequestParameter : uint64_t {
+  kGroupSequence = 0x0,
+  kObjectSequence = 0x1,
+  kAuthorizationInfo = 0x2,
+};
+
+struct QUICHE_EXPORT MoqtSetup {
+  uint64_t number_of_supported_versions;
+  std::vector<uint64_t> supported_versions;
+  absl::optional<MoqtRole> role;
+  absl::optional<absl::string_view> path;
+};
+
+struct QUICHE_EXPORT MoqtObject {
+  uint64_t track_id;
+  uint64_t group_sequence;
+  uint64_t object_sequence;
+  uint64_t object_send_order;
+  // Message also includes the object payload.
+};
+
+struct QUICHE_EXPORT MoqtSubscribeRequest {
+  absl::string_view full_track_name;
+  absl::optional<uint64_t> group_sequence;
+  absl::optional<uint64_t> object_sequence;
+  absl::optional<absl::string_view> authorization_info;
+};
+
+struct QUICHE_EXPORT MoqtSubscribeOk {
+  absl::string_view full_track_name;
+  uint64_t track_id;
+  // The message uses ms, but expires is in us.
+  quic::QuicTimeDelta expires = quic::QuicTimeDelta::FromMilliseconds(0);
+};
+
+struct QUICHE_EXPORT MoqtSubscribeError {
+  absl::string_view full_track_name;
+  uint64_t error_code;
+  absl::string_view reason_phrase;
+};
+
+struct QUICHE_EXPORT MoqtAnnounce {
+  absl::string_view track_namespace;
+  absl::optional<absl::string_view> authorization_info;
+};
+
+struct QUICHE_EXPORT MoqtAnnounceOk {
+  absl::string_view track_namespace;
+};
+
+struct QUICHE_EXPORT MoqtAnnounceError {
+  absl::string_view track_namespace;
+  uint64_t error_code;
+  absl::string_view reason_phrase;
+};
+
+struct QUICHE_EXPORT MoqtGoAway {};
+
+std::string MoqtMessageTypeToString(MoqtMessageType message_type);
+
+}  // namespace moqt
+
+#endif  // QUICHE_QUIC_MOQT_MOQT_MESSAGES_H_
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
new file mode 100644
index 0000000..d90af04
--- /dev/null
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -0,0 +1,688 @@
+// Copyright (c) 2023 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/moqt/moqt_parser.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <string>
+
+#include "absl/cleanup/cleanup.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "quiche/quic/core/quic_data_reader.h"
+#include "quiche/quic/core/quic_time.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/moqt/moqt_messages.h"
+#include "quiche/common/platform/api/quiche_logging.h"
+#include "quiche/common/quiche_endian.h"
+
+namespace moqt {
+
+namespace {
+
+// Minus the type, length, and payload, an OBJECT consists of 4 Varints.
+constexpr size_t kMaxObjectHeaderSize = 32;
+
+}  // namespace
+
+// The buffering philosophy is complicated, to minimize copying. Here is an
+// overview:
+// If the message type is present, this is stored in message_type_. If part of
+// the message type varint is partially present, that is buffered (requiring a
+// copy).
+// Same for message length.
+// If the entire message body is present (except for OBJECT payload), it is
+// parsed and delivered. If not, the partial body is buffered. (requiring a
+// copy).
+// Any OBJECT payload is always delivered to the application without copying.
+// If something has been buffered, when more data arrives copy just enough of it
+// to finish parsing that thing, then resume normal processing.
+void MoqtParser::ProcessData(absl::string_view data, bool end_of_stream) {
+  if (no_more_data_) {
+    if (!data.empty() || !end_of_stream) {
+      ParseError("Data after end of stream");
+    }
+    return;
+  }
+  if (processing_) {
+    return;
+  }
+  processing_ = true;
+  auto on_return = absl::MakeCleanup([&] { processing_ = false; });
+  no_more_data_ = end_of_stream;
+  quic::QuicDataReader reader(data);
+  if (!MaybeMergeDataWithBuffer(reader, end_of_stream)) {
+    return;
+  }
+  if (end_of_stream && reader.IsDoneReading() && object_metadata_.has_value()) {
+    // A FIN arrives while delivering OBJECT payload.
+    visitor_.OnObjectMessage(object_metadata_.value(), data, true);
+    EndOfMessage();
+  }
+  while (!reader.IsDoneReading()) {
+    absl::optional<size_t> processed;
+    if (!GetMessageTypeAndLength(reader)) {
+      absl::StrAppend(&buffered_message_, reader.PeekRemainingPayload());
+      break;
+    }
+    // Cursor is at start of the message.
+    if (end_of_stream && NoMessageLength()) {
+      *message_length_ = reader.BytesRemaining();
+    }
+    if (*message_type_ != MoqtMessageType::kObject &&
+        *message_type_ != MoqtMessageType::kGoAway) {
+      // Parse OBJECT in case the message is very large. GOAWAY is length zero,
+      // so always process.
+      if (NoMessageLength()) {
+        // Can't parse it yet.
+        absl::StrAppend(&buffered_message_, reader.PeekRemainingPayload());
+        break;
+      }
+      if (*message_length_ > kMaxMessageHeaderSize) {
+        ParseError("Message too long");
+        return;
+      }
+      if (*message_length_ > reader.BytesRemaining()) {
+        // There definitely isn't enough to process the message.
+        absl::StrAppend(&buffered_message_, reader.PeekRemainingPayload());
+        break;
+      }
+    }
+    processed = ProcessMessage(FetchMessage(reader));
+    if (!processed.has_value()) {
+      if (*message_type_ == MoqtMessageType::kObject &&
+          (NoMessageLength() || reader.BytesRemaining() < *message_length_)) {
+        // The parser can attempt to process OBJECT before receiving the whole
+        // message length. If it doesn't parse the varints, it will buffer the
+        // message.
+        absl::StrAppend(&buffered_message_, reader.PeekRemainingPayload());
+        break;
+      }
+      // Non-OBJECT or OBJECT with the complete specified length, but the data
+      // was not parseable.
+      ParseError("Not able to parse message given specified length");
+      return;
+    }
+    if (*processed == *message_length_) {
+      EndOfMessage();
+    } else {
+      if (*message_type_ != MoqtMessageType::kObject) {
+        // Partial processing of non-OBJECT is not allowed.
+        ParseError("Specified message length too long");
+        return;
+      }
+      // This is a partially processed OBJECT payload.
+      if (!NoMessageLength()) {
+        *message_length_ -= *processed;
+      }
+    }
+    if (!reader.Seek(*processed)) {
+      QUICHE_DCHECK(false);
+      ParseError("Internal Error");
+    }
+  }
+  if (end_of_stream &&
+      (!buffered_message_.empty() || object_metadata_.has_value() ||
+       message_type_.has_value() || message_length_.has_value())) {
+    // If the stream is ending, there should be no message in progress.
+    ParseError("Incomplete message at end of stream");
+  }
+}
+
+bool MoqtParser::MaybeMergeDataWithBuffer(quic::QuicDataReader& reader,
+                                          bool end_of_stream) {
+  // Copy as much information as necessary from |data| to complete the
+  // message or OBJECT header. Minimize unnecessary copying!
+  if (buffered_message_.empty()) {
+    return true;
+  }
+  quic::QuicDataReader buffer(buffered_message_);
+  if (!message_length_.has_value()) {
+    // The buffer contains part of the message type or length.
+    if (buffer.BytesRemaining() > buffer.PeekVarInt62Length()) {
+      ParseError("Internal Error");
+      QUICHE_DCHECK(false);
+      return false;
+    }
+    size_t bytes_needed = buffer.PeekVarInt62Length() - buffer.BytesRemaining();
+    if (bytes_needed > reader.BytesRemaining()) {
+      // Not enough to complete!
+      absl::StrAppend(&buffered_message_, reader.PeekRemainingPayload());
+      return false;
+    }
+    absl::StrAppend(&buffered_message_,
+                    reader.PeekRemainingPayload().substr(0, bytes_needed));
+    if (!reader.Seek(bytes_needed)) {
+      QUICHE_DCHECK(false);
+      ParseError("Internal Error");
+      return false;
+    }
+    quic::QuicDataReader new_buffer(buffered_message_);
+    uint64_t value;
+    if (!new_buffer.ReadVarInt62(&value)) {
+      QUICHE_DCHECK(false);
+      ParseError("Internal Error");
+      return false;
+    }
+    if (message_type_.has_value()) {
+      message_length_ = value;
+    } else {
+      message_type_ = static_cast<MoqtMessageType>(value);
+    }
+    // GOAWAY is special. Report the message as soon as the type and length
+    // are complete.
+    if (message_type_.has_value() && message_length_.has_value() &&
+        *message_type_ == MoqtMessageType::kGoAway) {
+      ProcessGoAway(new_buffer.PeekRemainingPayload());
+      EndOfMessage();
+      return false;
+    }
+    // Proceed to normal parsing.
+    buffered_message_.clear();
+    return true;
+  }
+  // It's a partially buffered message
+  if (NoMessageLength()) {
+    if (end_of_stream) {
+      message_length_ = buffer.BytesRemaining() + reader.BytesRemaining();
+    } else if (*message_type_ != MoqtMessageType::kObject) {
+      absl::StrAppend(&buffered_message_, reader.PeekRemainingPayload());
+      return false;
+    }
+  }
+  if (*message_type_ == MoqtMessageType::kObject) {
+    // OBJECT is a special case. Append up to KMaxObjectHeaderSize bytes to the
+    // buffer and see if that allows parsing.
+    QUICHE_DCHECK(!object_metadata_.has_value());
+    size_t original_buffer_size = buffer.BytesRemaining();
+    size_t bytes_to_pull = reader.BytesRemaining();
+    // No check for *message_length_ == 0 below! Mutants will complain if there
+    // is a check. If message_length_ < original_buffer_size, the second
+    // argument will be a very large unsigned integer, which will be irrelevant
+    // due to std::min.
+    bytes_to_pull = std::min(reader.BytesRemaining(),
+                             *message_length_ - original_buffer_size);
+    // Mutants complains that the line below doesn't fail any tests. This is a
+    // performance optimization to avoid copying large amounts of object payload
+    // into the buffer when only the OBJECT header will be processed. There is
+    // no observable behavior change if this line is removed.
+    bytes_to_pull = std::min(bytes_to_pull, kMaxObjectHeaderSize);
+    absl::StrAppend(&buffered_message_,
+                    reader.PeekRemainingPayload().substr(0, bytes_to_pull));
+    absl::optional<size_t> processed =
+        ProcessObjectVarints(absl::string_view(buffered_message_));
+    if (!processed.has_value()) {
+      if ((!NoMessageLength() &&
+           buffered_message_.length() == *message_length_) ||
+          buffered_message_.length() > kMaxObjectHeaderSize) {
+        ParseError("Not able to parse buffered message given specified length");
+      }
+      return false;
+    }
+    if (*processed > 0 && !reader.Seek(*processed - original_buffer_size)) {
+      ParseError("Internal Error");
+      return false;
+    }
+    if (*processed == *message_length_) {
+      // This covers an edge case where the peer has sent an OBJECT message with
+      // no content.
+      visitor_.OnObjectMessage(object_metadata_.value(), absl::string_view(),
+                               true);
+      EndOfMessage();
+      return true;
+    }
+    if (!NoMessageLength()) {
+      *message_length_ -= *processed;
+    }
+    // Object payload is never processed in the buffer.
+    buffered_message_.clear();
+    return true;
+  }
+  size_t bytes_to_pull =
+      (buffer.BytesRemaining() + reader.BytesRemaining() < *message_length_)
+          ? reader.BytesRemaining()
+          : *message_length_ - buffer.BytesRemaining();
+  absl::StrAppend(&buffered_message_,
+                  reader.PeekRemainingPayload().substr(0, bytes_to_pull));
+  if (!reader.Seek(bytes_to_pull)) {
+    QUICHE_DCHECK(false);
+    ParseError("Internal Error");
+    return false;
+  }
+  if (buffered_message_.length() < *message_length_) {
+    // Not enough bytes present.
+    return false;
+  }
+  absl::optional<size_t> processed =
+      ProcessMessage(absl::string_view(buffered_message_));
+  if (!processed.has_value()) {
+    ParseError("Not able to parse buffered message given specified length");
+    return false;
+  }
+  if (*processed != *message_length_) {
+    ParseError("Buffered message length too long for message contents");
+    return false;
+  }
+  EndOfMessage();
+  return true;
+}
+
+absl::optional<size_t> MoqtParser::ProcessMessage(absl::string_view data) {
+  switch (*message_type_) {
+    case MoqtMessageType::kObject:
+      return ProcessObject(data);
+    case MoqtMessageType::kSetup:
+      return ProcessSetup(data);
+    case MoqtMessageType::kSubscribeRequest:
+      return ProcessSubscribeRequest(data);
+    case MoqtMessageType::kSubscribeOk:
+      return ProcessSubscribeOk(data);
+    case MoqtMessageType::kSubscribeError:
+      return ProcessSubscribeError(data);
+    case MoqtMessageType::kAnnounce:
+      return ProcessAnnounce(data);
+    case MoqtMessageType::kAnnounceOk:
+      return ProcessAnnounceOk(data);
+    case MoqtMessageType::kAnnounceError:
+      return ProcessAnnounceError(data);
+    case MoqtMessageType::kGoAway:
+      return ProcessGoAway(data);
+    default:
+      ParseError("Unknown message type");
+      return absl::nullopt;
+  }
+}
+
+absl::optional<size_t> MoqtParser::ProcessObjectVarints(
+    absl::string_view data) {
+  if (object_metadata_.has_value()) {
+    return 0;
+  }
+  object_metadata_ = MoqtObject();
+  quic::QuicDataReader reader(data);
+  if (reader.ReadVarInt62(&object_metadata_->track_id) &&
+      reader.ReadVarInt62(&object_metadata_->group_sequence) &&
+      reader.ReadVarInt62(&object_metadata_->object_sequence) &&
+      reader.ReadVarInt62(&object_metadata_->object_send_order)) {
+    return reader.PreviouslyReadPayload().length();
+  }
+  object_metadata_ = absl::nullopt;
+  QUICHE_DCHECK(reader.PreviouslyReadPayload().length() < kMaxObjectHeaderSize);
+  return absl::nullopt;
+}
+
+absl::optional<size_t> MoqtParser::ProcessObject(absl::string_view data) {
+  quic::QuicDataReader reader(data);
+  size_t payload_length = *message_length_;
+  absl::optional<size_t> processed = ProcessObjectVarints(data);
+  if (!processed.has_value() && !object_metadata_.has_value()) {
+    // Could not obtain the whole object header.
+    return absl::nullopt;
+  }
+  if (!reader.Seek(*processed)) {
+    ParseError("Internal Error");
+    return absl::nullopt;
+  }
+  if (payload_length != 0) {
+    payload_length -= *processed;
+  }
+  QUICHE_DCHECK(NoMessageLength() || reader.BytesRemaining() <= payload_length);
+  visitor_.OnObjectMessage(
+      object_metadata_.value(), reader.PeekRemainingPayload(),
+      reader.BytesRemaining() == payload_length && !NoMessageLength());
+  return data.length();
+}
+
+absl::optional<size_t> MoqtParser::ProcessSetup(absl::string_view data) {
+  MoqtSetup setup;
+  quic::QuicDataReader reader(data);
+  if (perspective_ == quic::Perspective::IS_SERVER) {
+    if (!reader.ReadVarInt62(&setup.number_of_supported_versions)) {
+      return absl::nullopt;
+    }
+  } else {
+    setup.number_of_supported_versions = 1;
+  }
+  uint64_t value;
+  for (uint64_t i = 0; i < setup.number_of_supported_versions; ++i) {
+    if (!reader.ReadVarInt62(&value)) {
+      return absl::nullopt;
+    }
+    setup.supported_versions.push_back(value);
+  }
+  // Parse parameters
+  while (!reader.IsDoneReading()) {
+    if (!reader.ReadVarInt62(&value)) {
+      return absl::nullopt;
+    }
+    auto parameter_key = static_cast<MoqtSetupParameter>(value);
+    absl::string_view field;
+    switch (parameter_key) {
+      case MoqtSetupParameter::kRole:
+        if (setup.role.has_value()) {
+          ParseError("ROLE parameter appears twice in SETUP");
+          return absl::nullopt;
+        }
+        if (perspective_ == quic::Perspective::IS_CLIENT) {
+          ParseError("ROLE parameter sent by server in SETUP");
+          return absl::nullopt;
+        }
+        if (!ReadIntegerPieceVarInt62(reader, value)) {
+          return absl::nullopt;
+        }
+        setup.role = static_cast<MoqtRole>(value);
+        break;
+      case MoqtSetupParameter::kPath:
+        if (uses_web_transport_) {
+          ParseError(
+              "WebTransport connection is using PATH parameter in SETUP");
+          return absl::nullopt;
+        }
+        if (perspective_ == quic::Perspective::IS_CLIENT) {
+          ParseError("PATH parameter sent by server in SETUP");
+          return absl::nullopt;
+        }
+        if (setup.path.has_value()) {
+          ParseError("PATH parameter appears twice in SETUP");
+          return absl::nullopt;
+        }
+        if (!reader.ReadStringPieceVarInt62(&field)) {
+          return absl::nullopt;
+        }
+        setup.path = field;
+        break;
+      default:
+        // Skip over the parameter.
+        if (!reader.ReadStringPieceVarInt62(&field)) {
+          return absl::nullopt;
+        }
+        break;
+    }
+  }
+  if (perspective_ == quic::Perspective::IS_SERVER) {
+    if (!setup.role.has_value()) {
+      ParseError("ROLE SETUP parameter missing from Client message");
+      return absl::nullopt;
+    }
+    if (!uses_web_transport_ && !setup.path.has_value()) {
+      ParseError("PATH SETUP parameter missing from Client message over QUIC");
+      return absl::nullopt;
+    }
+  }
+  visitor_.OnSetupMessage(setup);
+  return reader.PreviouslyReadPayload().length();
+}
+
+absl::optional<size_t> MoqtParser::ProcessSubscribeRequest(
+    absl::string_view data) {
+  MoqtSubscribeRequest subscribe_request;
+  quic::QuicDataReader reader(data);
+  absl::string_view field;
+  if (!reader.ReadStringPieceVarInt62(&subscribe_request.full_track_name)) {
+    return absl::nullopt;
+  }
+  uint64_t value;
+  while (!reader.IsDoneReading()) {
+    if (!reader.ReadVarInt62(&value)) {
+      return absl::nullopt;
+    }
+    auto parameter_key = static_cast<MoqtTrackRequestParameter>(value);
+    switch (parameter_key) {
+      case MoqtTrackRequestParameter::kGroupSequence:
+        if (subscribe_request.group_sequence.has_value()) {
+          ParseError(
+              "GROUP_SEQUENCE parameter appears twice in SUBSCRIBE_REQUEST");
+          return absl::nullopt;
+        }
+        if (!ReadIntegerPieceVarInt62(reader, value)) {
+          return absl::nullopt;
+        }
+        subscribe_request.group_sequence = value;
+        break;
+      case MoqtTrackRequestParameter::kObjectSequence:
+        if (subscribe_request.object_sequence.has_value()) {
+          ParseError(
+              "OBJECT_SEQUENCE parameter appears twice in SUBSCRIBE_REQUEST");
+          return absl::nullopt;
+        }
+        if (!ReadIntegerPieceVarInt62(reader, value)) {
+          return absl::nullopt;
+        }
+        subscribe_request.object_sequence = value;
+        break;
+      case MoqtTrackRequestParameter::kAuthorizationInfo:
+        if (subscribe_request.authorization_info.has_value()) {
+          ParseError(
+              "AUTHORIZATION_INFO parameter appears twice in "
+              "SUBSCRIBE_REQUEST");
+          return absl::nullopt;
+        }
+        if (!reader.ReadStringPieceVarInt62(&field)) {
+          return absl::nullopt;
+        }
+        subscribe_request.authorization_info = field;
+        break;
+      default:
+        // Skip over the parameter.
+        if (!reader.ReadStringPieceVarInt62(&field)) {
+          return absl::nullopt;
+        }
+        break;
+    }
+  }
+  if (reader.IsDoneReading()) {
+    visitor_.OnSubscribeRequestMessage(subscribe_request);
+  }
+  return reader.PreviouslyReadPayload().length();
+}
+
+absl::optional<size_t> MoqtParser::ProcessSubscribeOk(absl::string_view data) {
+  MoqtSubscribeOk subscribe_ok;
+  quic::QuicDataReader reader(data);
+  if (!reader.ReadStringPieceVarInt62(&subscribe_ok.full_track_name)) {
+    return absl::nullopt;
+  }
+  if (!reader.ReadVarInt62(&subscribe_ok.track_id)) {
+    return absl::nullopt;
+  }
+  uint64_t milliseconds;
+  if (!reader.ReadVarInt62(&milliseconds)) {
+    return absl::nullopt;
+  }
+  subscribe_ok.expires = quic::QuicTimeDelta::FromMilliseconds(milliseconds);
+  if (reader.IsDoneReading()) {
+    visitor_.OnSubscribeOkMessage(subscribe_ok);
+  }
+  return reader.PreviouslyReadPayload().length();
+}
+
+absl::optional<size_t> MoqtParser::ProcessSubscribeError(
+    absl::string_view data) {
+  MoqtSubscribeError subscribe_error;
+  quic::QuicDataReader reader(data);
+  if (!reader.ReadStringPieceVarInt62(&subscribe_error.full_track_name)) {
+    return absl::nullopt;
+  }
+  if (!reader.ReadVarInt62(&subscribe_error.error_code)) {
+    return absl::nullopt;
+  }
+  if (!reader.ReadStringPieceVarInt62(&subscribe_error.reason_phrase)) {
+    return absl::nullopt;
+  }
+  if (reader.IsDoneReading()) {
+    visitor_.OnSubscribeErrorMessage(subscribe_error);
+  }
+  return reader.PreviouslyReadPayload().length();
+}
+
+absl::optional<size_t> MoqtParser::ProcessAnnounce(absl::string_view data) {
+  MoqtAnnounce announce;
+  quic::QuicDataReader reader(data);
+  absl::string_view field;
+  if (!reader.ReadStringPieceVarInt62(&field)) {
+    return absl::nullopt;
+  }
+  announce.track_namespace = field;
+  bool saw_group_sequence = false, saw_object_sequence = false;
+  while (!reader.IsDoneReading()) {
+    uint64_t value;
+    if (!reader.ReadVarInt62(&value)) {
+      return absl::nullopt;
+    }
+    auto parameter_key = static_cast<MoqtTrackRequestParameter>(value);
+    switch (parameter_key) {
+      case MoqtTrackRequestParameter::kGroupSequence:
+        // Not used, but check for duplicates.
+        if (saw_group_sequence) {
+          ParseError("GROUP_SEQUENCE parameter appears twice in ANNOUNCE");
+          return absl::nullopt;
+        }
+        if (!reader.ReadStringPieceVarInt62(&field)) {
+          return absl::nullopt;
+        }
+        saw_group_sequence = true;
+        break;
+      case MoqtTrackRequestParameter::kObjectSequence:
+        // Not used, but check for duplicates.
+        if (saw_object_sequence) {
+          ParseError("OBJECT_SEQUENCE parameter appears twice in ANNOUNCE");
+          return absl::nullopt;
+        }
+        if (!reader.ReadStringPieceVarInt62(&field)) {
+          return absl::nullopt;
+        }
+        saw_object_sequence = true;
+        break;
+      case MoqtTrackRequestParameter::kAuthorizationInfo:
+        if (announce.authorization_info.has_value()) {
+          ParseError("AUTHORIZATION_INFO parameter appears twice in ANNOUNCE");
+          return absl::nullopt;
+        }
+        if (!reader.ReadStringPieceVarInt62(&field)) {
+          return absl::nullopt;
+        }
+        announce.authorization_info = field;
+        break;
+      default:
+        // Skip over the parameter.
+        if (!reader.ReadStringPieceVarInt62(&field)) {
+          return absl::nullopt;
+        }
+        break;
+    }
+  }
+  if (reader.IsDoneReading()) {
+    visitor_.OnAnnounceMessage(announce);
+  }
+  return reader.PreviouslyReadPayload().length();
+}
+
+absl::optional<size_t> MoqtParser::ProcessAnnounceOk(absl::string_view data) {
+  MoqtAnnounceOk announce_ok;
+  quic::QuicDataReader reader(data);
+  if (!reader.ReadStringPiece(&announce_ok.track_namespace, data.length())) {
+    return absl::nullopt;
+  }
+  if (reader.IsDoneReading()) {
+    visitor_.OnAnnounceOkMessage(announce_ok);
+  }
+  return reader.PreviouslyReadPayload().length();
+}
+
+absl::optional<size_t> MoqtParser::ProcessAnnounceError(
+    absl::string_view data) {
+  MoqtAnnounceError announce_error;
+  quic::QuicDataReader reader(data);
+  if (!reader.ReadStringPieceVarInt62(&announce_error.track_namespace)) {
+    return absl::nullopt;
+  }
+  if (!reader.ReadVarInt62(&announce_error.error_code)) {
+    return absl::nullopt;
+  }
+  if (!reader.ReadStringPieceVarInt62(&announce_error.reason_phrase)) {
+    return absl::nullopt;
+  }
+  if (reader.IsDoneReading()) {
+    visitor_.OnAnnounceErrorMessage(announce_error);
+  }
+  return reader.PreviouslyReadPayload().length();
+}
+
+absl::optional<size_t> MoqtParser::ProcessGoAway(absl::string_view data) {
+  if (!data.empty()) {
+    // GOAWAY can only be followed by end_of_stream. Anything else is an error.
+    ParseError("GOAWAY has data following");
+    return absl::nullopt;
+  }
+  visitor_.OnGoAwayMessage();
+  return 0;
+}
+
+bool MoqtParser::GetMessageTypeAndLength(quic::QuicDataReader& reader) {
+  if (!message_type_.has_value()) {
+    uint64_t value;
+    if (!reader.ReadVarInt62(&value)) {
+      return false;
+    }
+    message_type_ = static_cast<MoqtMessageType>(value);
+  }
+  if (!message_length_.has_value()) {
+    uint64_t value;
+    if (!reader.ReadVarInt62(&value)) {
+      return false;
+    }
+    message_length_ = value;
+  }
+  return true;
+}
+
+void MoqtParser::EndOfMessage() {
+  buffered_message_.clear();
+  message_type_ = absl::nullopt;
+  message_length_ = absl::nullopt;
+  object_metadata_ = absl::nullopt;
+}
+
+absl::string_view MoqtParser::FetchMessage(quic::QuicDataReader& reader) {
+  if (message_length_ == 0) {
+    return reader.PeekRemainingPayload();
+  }
+  if (message_length_ > reader.BytesRemaining()) {
+    QUICHE_DCHECK(message_type_ == MoqtMessageType::kObject);
+    return reader.PeekRemainingPayload();
+  }
+  return reader.PeekRemainingPayload().substr(0, *message_length_);
+}
+
+void MoqtParser::ParseError(absl::string_view reason) {
+  if (parsing_error_) {
+    return;  // Don't send multiple parse errors.
+  }
+  no_more_data_ = true;
+  parsing_error_ = true;
+  visitor_.OnParsingError(reason);
+}
+
+bool MoqtParser::ReadIntegerPieceVarInt62(quic::QuicDataReader& reader,
+                                          uint64_t& result) {
+  absl::string_view field;
+  if (!reader.ReadStringPieceVarInt62(&field)) {
+    return false;
+  }
+  if (field.size() > sizeof(uint64_t)) {
+    ParseError("Cannot parse explicit length integers longer than 8 bytes");
+    return false;
+  }
+  result = 0;
+  memcpy((uint8_t*)&result + sizeof(result) - field.size(), field.data(),
+         field.size());
+  result = quiche::QuicheEndian::NetToHost64(result);
+  return true;
+}
+
+}  // namespace moqt
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h
new file mode 100644
index 0000000..d931922
--- /dev/null
+++ b/quiche/quic/moqt/moqt_parser.h
@@ -0,0 +1,137 @@
+// Copyright (c) 2023 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.
+
+// A parser for draft-ietf-moq-transport-00.
+
+#ifndef QUICHE_QUIC_MOQT_MOQT_PARSER_H_
+#define QUICHE_QUIC_MOQT_MOQT_PARSER_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "quiche/quic/core/quic_data_reader.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/moqt/moqt_messages.h"
+#include "quiche/common/platform/api/quiche_export.h"
+
+namespace moqt {
+
+class QUICHE_EXPORT MoqtParserVisitor {
+ public:
+  virtual ~MoqtParserVisitor() = default;
+
+  // If |end_of_message| is true, |payload| contains the last bytes of the
+  // OBJECT payload. If not, there will be subsequent calls with further payload
+  // data. The parser retains ownership of |message| and |payload|, so the
+  // visitor needs to copy anything it wants to retain.
+  virtual void OnObjectMessage(const MoqtObject& message,
+                               absl::string_view payload,
+                               bool end_of_message) = 0;
+  // All of these are called only when the entire specified message length has
+  // arrived, which requires a stream FIN if the length is zero. The parser
+  // retains ownership of the memory.
+  virtual void OnSetupMessage(const MoqtSetup& message) = 0;
+  virtual void OnSubscribeRequestMessage(
+      const MoqtSubscribeRequest& message) = 0;
+  virtual void OnSubscribeOkMessage(const MoqtSubscribeOk& message) = 0;
+  virtual void OnSubscribeErrorMessage(const MoqtSubscribeError& message) = 0;
+  virtual void OnAnnounceMessage(const MoqtAnnounce& message) = 0;
+  virtual void OnAnnounceOkMessage(const MoqtAnnounceOk& message) = 0;
+  virtual void OnAnnounceErrorMessage(const MoqtAnnounceError& message) = 0;
+  // In an exception to the above, the parser calls this when it gets two bytes,
+  // whether or not it includes stream FIN. When a zero-length message has
+  // special meaning, a message with an actual length of zero is tricky!
+  virtual void OnGoAwayMessage() = 0;
+
+  virtual void OnParsingError(absl::string_view reason) = 0;
+};
+
+class QUICHE_EXPORT MoqtParser {
+ public:
+  MoqtParser(quic::Perspective perspective, bool uses_web_transport,
+             MoqtParserVisitor& visitor)
+      : visitor_(visitor),
+        perspective_(perspective),
+        uses_web_transport_(uses_web_transport) {}
+  ~MoqtParser() = default;
+
+  // Take a buffer from the transport in |data|. Parse each complete message and
+  // call the appropriate visitor function. If |end_of_stream| is true, there
+  // is no more data arriving on the stream, so the parser will deliver any
+  // message encoded as to run to the end of the stream.
+  // All bytes can be freed. Calls OnParsingError() when there is a parsing
+  // error.
+  // Any calls after sending |end_of_stream| = true will be ignored.
+  void ProcessData(absl::string_view data, bool end_of_stream);
+
+ private:
+  // Copies the minimum amount of data in |reader| to buffered_message_ in order
+  // to process what is in there, and does the processing. Returns true if
+  // additional processing can occur, false otherwise.
+  bool MaybeMergeDataWithBuffer(quic::QuicDataReader& reader,
+                                bool end_of_stream);
+
+  // The central switch statement to dispatch a message to the correct
+  // Process* function. Returns nullopt if it could not parse the full messsage
+  // (except for object payload). Otherwise, returns the number of bytes
+  // processed.
+  absl::optional<size_t> ProcessMessage(absl::string_view data);
+  // A helper function to parse just the varints in an OBJECT.
+  absl::optional<size_t> ProcessObjectVarints(absl::string_view data);
+  // The Process* functions parse the serialized data into the appropriate
+  // structs, and call the relevant visitor function for further action. Returns
+  // the number of bytes consumed if the message is complete; returns nullopt
+  // otherwise. These functions can throw a fatal error if the message length
+  // is insufficient.
+  absl::optional<size_t> ProcessObject(absl::string_view data);
+  absl::optional<size_t> ProcessSetup(absl::string_view data);
+  absl::optional<size_t> ProcessSubscribeRequest(absl::string_view data);
+  absl::optional<size_t> ProcessSubscribeOk(absl::string_view data);
+  absl::optional<size_t> ProcessSubscribeError(absl::string_view data);
+  absl::optional<size_t> ProcessAnnounce(absl::string_view data);
+  absl::optional<size_t> ProcessAnnounceOk(absl::string_view data);
+  absl::optional<size_t> ProcessAnnounceError(absl::string_view data);
+  absl::optional<size_t> ProcessGoAway(absl::string_view data);
+
+  // If the message length field is zero, it runs to the end of the stream.
+  bool NoMessageLength() { return *message_length_ == 0; }
+  // If type and or length are not already stored for this message, reads it out
+  // of the data in |reader| and stores it in the appropriate members. Returns
+  // false if length is not available.
+  bool GetMessageTypeAndLength(quic::QuicDataReader& reader);
+  void EndOfMessage();
+  // Get a string_view of the part of the reader covered by message_length_,
+  // with exceptions for OBJECT messages.
+  absl::string_view FetchMessage(quic::QuicDataReader& reader);
+  void ParseError(absl::string_view reason);
+
+  // Reads an integer whose length is specified by a preceding VarInt62 and
+  // returns it in |result|. Returns false if parsing fails.
+  bool ReadIntegerPieceVarInt62(quic::QuicDataReader& reader, uint64_t& result);
+
+  MoqtParserVisitor& visitor_;
+  // Client or server?
+  quic::Perspective perspective_;
+  bool uses_web_transport_;
+  bool no_more_data_ = false;  // Fatal error or end_of_stream. No more parsing.
+  bool parsing_error_ = false;
+
+  std::string buffered_message_;
+  absl::optional<MoqtMessageType> message_type_ = absl::nullopt;
+  absl::optional<size_t> message_length_ = absl::nullopt;
+
+  // Metadata for an object which is delivered in parts.
+  absl::optional<MoqtObject> object_metadata_ = absl::nullopt;
+
+  bool processing_ = false;  // True if currently in ProcessData(), to prevent
+                             // re-entrancy.
+};
+
+}  // namespace moqt
+
+#endif  // QUICHE_QUIC_MOQT_MOQT_PARSER_H_
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc
new file mode 100644
index 0000000..357be26
--- /dev/null
+++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -0,0 +1,858 @@
+// Copyright (c) 2023 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/moqt/moqt_parser.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "quiche/quic/core/quic_types.h"
+#include "quiche/quic/moqt/moqt_messages.h"
+#include "quiche/quic/moqt/test_tools/moqt_test_message.h"
+#include "quiche/quic/platform/api/quic_test.h"
+
+namespace moqt::test {
+
+struct MoqtParserTestParams {
+  MoqtParserTestParams(MoqtMessageType message_type,
+                       quic::Perspective perspective, bool uses_web_transport)
+      : message_type(message_type),
+        perspective(perspective),
+        uses_web_transport(uses_web_transport) {}
+  MoqtMessageType message_type;
+  quic::Perspective perspective;
+  bool uses_web_transport;
+};
+
+std::vector<MoqtParserTestParams> GetMoqtParserTestParams() {
+  std::vector<MoqtParserTestParams> params;
+  std::vector<MoqtMessageType> message_types = {
+      MoqtMessageType::kObject,           MoqtMessageType::kSetup,
+      MoqtMessageType::kSubscribeRequest, MoqtMessageType::kSubscribeOk,
+      MoqtMessageType::kSubscribeError,   MoqtMessageType::kAnnounce,
+      MoqtMessageType::kAnnounceOk,       MoqtMessageType::kAnnounceError,
+      MoqtMessageType::kGoAway,
+  };
+  std::vector<quic::Perspective> perspectives = {
+      quic::Perspective::IS_SERVER,
+      quic::Perspective::IS_CLIENT,
+  };
+  std::vector<bool> uses_web_transport_bool = {
+      false,
+      true,
+  };
+  for (const MoqtMessageType message_type : message_types) {
+    if (message_type == MoqtMessageType::kSetup) {
+      for (const quic::Perspective perspective : perspectives) {
+        for (const bool uses_web_transport : uses_web_transport_bool) {
+          params.push_back(MoqtParserTestParams(message_type, perspective,
+                                                uses_web_transport));
+        }
+      }
+    } else {
+      // All other types are processed the same for either perspective or
+      // transport.
+      params.push_back(MoqtParserTestParams(
+          message_type, quic::Perspective::IS_SERVER, true));
+    }
+  }
+  return params;
+}
+
+std::string ParamNameFormatter(
+    const testing::TestParamInfo<MoqtParserTestParams>& info) {
+  return MoqtMessageTypeToString(info.param.message_type) + "_" +
+         (info.param.perspective == quic::Perspective::IS_SERVER ? "Server"
+                                                                 : "Client") +
+         "_" + (info.param.uses_web_transport ? "WebTransport" : "QUIC");
+}
+
+class MoqtParserTestVisitor : public MoqtParserVisitor {
+ public:
+  ~MoqtParserTestVisitor() = default;
+
+  void OnObjectMessage(const MoqtObject& message, absl::string_view payload,
+                       bool end_of_message) override {
+    object_payload_ = payload;
+    end_of_message_ = end_of_message;
+    messages_received_++;
+    last_message_ = TestMessageBase::MessageStructuredData(message);
+  }
+  void OnSetupMessage(const MoqtSetup& message) override {
+    end_of_message_ = true;
+    messages_received_++;
+    MoqtSetup setup = message;
+    if (setup.path.has_value()) {
+      string0_ = std::string(setup.path.value());
+      setup.path = absl::string_view(string0_);
+    }
+    last_message_ = TestMessageBase::MessageStructuredData(setup);
+  }
+  void OnSubscribeRequestMessage(const MoqtSubscribeRequest& message) override {
+    end_of_message_ = true;
+    messages_received_++;
+    MoqtSubscribeRequest subscribe_request = message;
+    string0_ = std::string(subscribe_request.full_track_name);
+    subscribe_request.full_track_name = absl::string_view(string0_);
+    if (subscribe_request.authorization_info.has_value()) {
+      string1_ = std::string(subscribe_request.authorization_info.value());
+      subscribe_request.authorization_info = absl::string_view(string1_);
+    }
+    last_message_ = TestMessageBase::MessageStructuredData(subscribe_request);
+  }
+  void OnSubscribeOkMessage(const MoqtSubscribeOk& message) override {
+    end_of_message_ = true;
+    messages_received_++;
+    MoqtSubscribeOk subscribe_ok = message;
+    string0_ = std::string(subscribe_ok.full_track_name);
+    subscribe_ok.full_track_name = absl::string_view(string0_);
+    last_message_ = TestMessageBase::MessageStructuredData(subscribe_ok);
+  }
+  void OnSubscribeErrorMessage(const MoqtSubscribeError& message) override {
+    end_of_message_ = true;
+    messages_received_++;
+    MoqtSubscribeError subscribe_error = message;
+    string0_ = std::string(subscribe_error.full_track_name);
+    subscribe_error.full_track_name = absl::string_view(string0_);
+    string1_ = std::string(subscribe_error.reason_phrase);
+    subscribe_error.reason_phrase = absl::string_view(string1_);
+    last_message_ = TestMessageBase::MessageStructuredData(subscribe_error);
+  }
+  void OnAnnounceMessage(const MoqtAnnounce& message) override {
+    end_of_message_ = true;
+    messages_received_++;
+    MoqtAnnounce announce = message;
+    string0_ = std::string(announce.track_namespace);
+    announce.track_namespace = absl::string_view(string0_);
+    if (announce.authorization_info.has_value()) {
+      string1_ = std::string(announce.authorization_info.value());
+      announce.authorization_info = absl::string_view(string1_);
+    }
+    last_message_ = TestMessageBase::MessageStructuredData(announce);
+  }
+  void OnAnnounceOkMessage(const MoqtAnnounceOk& message) override {
+    end_of_message_ = true;
+    messages_received_++;
+    MoqtAnnounceOk announce_ok = message;
+    string0_ = std::string(announce_ok.track_namespace);
+    announce_ok.track_namespace = absl::string_view(string0_);
+    last_message_ = TestMessageBase::MessageStructuredData(announce_ok);
+  }
+  void OnAnnounceErrorMessage(const MoqtAnnounceError& message) override {
+    end_of_message_ = true;
+    messages_received_++;
+    MoqtAnnounceError announce_error = message;
+    string0_ = std::string(announce_error.track_namespace);
+    announce_error.track_namespace = absl::string_view(string0_);
+    string1_ = std::string(announce_error.reason_phrase);
+    announce_error.reason_phrase = absl::string_view(string1_);
+    last_message_ = TestMessageBase::MessageStructuredData(announce_error);
+  }
+  void OnGoAwayMessage() override {
+    got_goaway_ = true;
+    end_of_message_ = true;
+    messages_received_++;
+    last_message_ = TestMessageBase::MessageStructuredData();
+  }
+  void OnParsingError(absl::string_view reason) override {
+    QUIC_LOG(INFO) << "Parsing error: " << reason;
+    parsing_error_ = reason;
+  }
+
+  absl::optional<absl::string_view> object_payload_;
+  bool end_of_message_ = false;
+  bool got_goaway_ = false;
+  absl::optional<absl::string_view> parsing_error_;
+  uint64_t messages_received_ = 0;
+  absl::optional<TestMessageBase::MessageStructuredData> last_message_;
+  // Stored strings for last_message_. The visitor API does not promise the
+  // memory pointed to by string_views is persistent.
+  std::string string0_, string1_;
+};
+
+class MoqtParserTest
+    : public quic::test::QuicTestWithParam<MoqtParserTestParams> {
+ public:
+  MoqtParserTest()
+      : message_type_(GetParam().message_type),
+        is_client_(GetParam().perspective == quic::Perspective::IS_CLIENT),
+        webtrans_(GetParam().uses_web_transport),
+        parser_(GetParam().perspective, GetParam().uses_web_transport,
+                visitor_) {}
+
+  std::unique_ptr<TestMessageBase> MakeMessage(MoqtMessageType message_type) {
+    switch (message_type) {
+      case MoqtMessageType::kObject:
+        return std::make_unique<ObjectMessage>();
+      case MoqtMessageType::kSetup:
+        return std::make_unique<SetupMessage>(is_client_, webtrans_);
+      case MoqtMessageType::kSubscribeRequest:
+        return std::make_unique<SubscribeRequestMessage>();
+      case MoqtMessageType::kSubscribeOk:
+        return std::make_unique<SubscribeOkMessage>();
+      case MoqtMessageType::kSubscribeError:
+        return std::make_unique<SubscribeErrorMessage>();
+      case MoqtMessageType::kAnnounce:
+        return std::make_unique<AnnounceMessage>();
+      case moqt::MoqtMessageType::kAnnounceOk:
+        return std::make_unique<AnnounceOkMessage>();
+      case moqt::MoqtMessageType::kAnnounceError:
+        return std::make_unique<AnnounceErrorMessage>();
+      case moqt::MoqtMessageType::kGoAway:
+        return std::make_unique<GoAwayMessage>();
+      default:
+        return nullptr;
+    }
+  }
+
+  MoqtParserTestVisitor visitor_;
+  MoqtMessageType message_type_;
+  bool is_client_;
+  bool webtrans_;
+  MoqtParser parser_;
+};
+
+INSTANTIATE_TEST_SUITE_P(MoqtParserTests, MoqtParserTest,
+                         testing::ValuesIn(GetMoqtParserTestParams()),
+                         ParamNameFormatter);
+
+TEST_P(MoqtParserTest, OneMessage) {
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  parser_.ProcessData(message->PacketSample(), false);
+  EXPECT_EQ(visitor_.messages_received_, 1);
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.end_of_message_);
+  if (message_type_ == MoqtMessageType::kObject) {
+    // Check payload message.
+    EXPECT_TRUE(visitor_.object_payload_.has_value());
+    EXPECT_EQ(*(visitor_.object_payload_), "foo");
+  }
+}
+
+TEST_P(MoqtParserTest, OneMessageWithLongVarints) {
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  message->ExpandVarints();
+  parser_.ProcessData(message->PacketSample(), false);
+  EXPECT_EQ(visitor_.messages_received_, 1);
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.end_of_message_);
+  if (message_type_ == MoqtMessageType::kObject) {
+    // Check payload message.
+    EXPECT_EQ(visitor_.object_payload_, "foo");
+  }
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+}
+
+TEST_P(MoqtParserTest, MessageNoLengthWithFin) {
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  message->set_message_size(0);
+  parser_.ProcessData(message->PacketSample(), true);
+  EXPECT_EQ(visitor_.messages_received_, 1);
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.end_of_message_);
+  if (message_type_ == MoqtMessageType::kObject) {
+    // Check payload message.
+    EXPECT_TRUE(visitor_.object_payload_.has_value());
+    EXPECT_EQ(*(visitor_.object_payload_), "foo");
+  }
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+}
+
+TEST_P(MoqtParserTest, MessageNoLengthSeparateFinObjectOrGoAway) {
+  // OBJECT and GOAWAY can return on a zero-length message even without
+  // receiving a FIN.
+  if (message_type_ != MoqtMessageType::kObject &&
+      message_type_ != MoqtMessageType::kGoAway) {
+    return;
+  }
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  message->set_message_size(0);
+  parser_.ProcessData(message->PacketSample(), false);
+  EXPECT_EQ(visitor_.messages_received_, 1);
+  if (message_type_ == MoqtMessageType::kGoAway) {
+    EXPECT_TRUE(visitor_.got_goaway_);
+    EXPECT_TRUE(visitor_.end_of_message_);
+    return;
+  }
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.object_payload_.has_value());
+  EXPECT_EQ(*(visitor_.object_payload_), "foo");
+  EXPECT_FALSE(visitor_.end_of_message_);
+
+  parser_.ProcessData(absl::string_view(), true);  // send the FIN
+  EXPECT_EQ(visitor_.messages_received_, 2);
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.object_payload_.has_value());
+  EXPECT_EQ(*(visitor_.object_payload_), "");
+  EXPECT_TRUE(visitor_.end_of_message_);
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+}
+
+TEST_P(MoqtParserTest, MessageNoLengthSeparateFinOtherTypes) {
+  if (message_type_ == MoqtMessageType::kObject ||
+      message_type_ == MoqtMessageType::kGoAway) {
+    return;
+  }
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  message->set_message_size(0);
+  parser_.ProcessData(message->PacketSample(), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  parser_.ProcessData(absl::string_view(), true);  // send the FIN
+  EXPECT_EQ(visitor_.messages_received_, 1);
+
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.end_of_message_);
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+}
+
+TEST_P(MoqtParserTest, TwoPartMessage) {
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  // The test Object message has payload for less then half the message length,
+  // so splitting the message in half will prevent the first half from being
+  // processed.
+  size_t first_data_size = message->total_message_size() / 2;
+  parser_.ProcessData(message->PacketSample().substr(0, first_data_size),
+                      false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  parser_.ProcessData(
+      message->PacketSample().substr(
+          first_data_size, message->total_message_size() - first_data_size),
+      false);
+  EXPECT_EQ(visitor_.messages_received_, 1);
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.end_of_message_);
+  if (message_type_ == MoqtMessageType::kObject) {
+    EXPECT_EQ(visitor_.object_payload_, "foo");
+  }
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+}
+
+// Send the header + some payload, pure payload, then pure payload to end the
+// message.
+TEST_P(MoqtParserTest, ThreePartObject) {
+  if (message_type_ != MoqtMessageType::kObject) {
+    return;
+  }
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  message->set_message_size(0);
+  // The test Object message has payload for less then half the message length,
+  // so splitting the message in half will prevent the first half from being
+  // processed.
+  parser_.ProcessData(message->PacketSample(), false);
+  EXPECT_EQ(visitor_.messages_received_, 1);
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_FALSE(visitor_.end_of_message_);
+  EXPECT_TRUE(visitor_.object_payload_.has_value());
+  EXPECT_EQ(*(visitor_.object_payload_), "foo");
+
+  // second part
+  parser_.ProcessData("bar", false);
+  EXPECT_EQ(visitor_.messages_received_, 2);
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_FALSE(visitor_.end_of_message_);
+  EXPECT_TRUE(visitor_.object_payload_.has_value());
+  EXPECT_EQ(*(visitor_.object_payload_), "bar");
+
+  // third part includes FIN
+  parser_.ProcessData("deadbeef", true);
+  EXPECT_EQ(visitor_.messages_received_, 3);
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.end_of_message_);
+  EXPECT_TRUE(visitor_.object_payload_.has_value());
+  EXPECT_EQ(*(visitor_.object_payload_), "deadbeef");
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+}
+
+// Send the part of header, rest of header + payload, plus payload.
+TEST_P(MoqtParserTest, ThreePartObjectFirstIncomplete) {
+  if (message_type_ != MoqtMessageType::kObject) {
+    return;
+  }
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  message->set_message_size(0);
+
+  // first part
+  parser_.ProcessData(message->PacketSample().substr(0, 4), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+
+  // second part. Add padding to it.
+  message->set_wire_image_size(100);
+  parser_.ProcessData(
+      message->PacketSample().substr(4, message->total_message_size() - 4),
+      false);
+  EXPECT_EQ(visitor_.messages_received_, 1);
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_FALSE(visitor_.end_of_message_);
+  EXPECT_TRUE(visitor_.object_payload_.has_value());
+  EXPECT_EQ(visitor_.object_payload_->length(), 94);
+
+  // third part includes FIN
+  parser_.ProcessData("bar", true);
+  EXPECT_EQ(visitor_.messages_received_, 2);
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.end_of_message_);
+  EXPECT_TRUE(visitor_.object_payload_.has_value());
+  EXPECT_EQ(*(visitor_.object_payload_), "bar");
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+}
+
+TEST_P(MoqtParserTest, OneByteAtATime) {
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  message->set_message_size(0);
+  constexpr size_t kObjectPrePayloadSize = 6;
+  for (size_t i = 0; i < message->total_message_size(); ++i) {
+    parser_.ProcessData(message->PacketSample().substr(i, 1), false);
+    if (message_type_ == MoqtMessageType::kGoAway &&
+        i == message->total_message_size() - 1) {
+      // OnGoAway() is called before FIN.
+      EXPECT_EQ(visitor_.messages_received_, 1);
+      EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+      EXPECT_TRUE(visitor_.end_of_message_);
+      break;
+    }
+    if (message_type_ != MoqtMessageType::kObject ||
+        i < kObjectPrePayloadSize) {
+      // OBJECTs will have to buffer for the first 5 bytes (until the varints
+      // are done). The sixth byte is a bare OBJECT header, so the parser does
+      // not notify the visitor.
+      EXPECT_EQ(visitor_.messages_received_, 0);
+    } else {
+      // OBJECT payload processing.
+      EXPECT_EQ(visitor_.messages_received_, i - kObjectPrePayloadSize + 1);
+      EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+      EXPECT_TRUE(visitor_.object_payload_.has_value());
+      if (i == 5) {
+        EXPECT_EQ(visitor_.object_payload_->length(), 0);
+      } else {
+        EXPECT_EQ(visitor_.object_payload_->length(), 1);
+        EXPECT_EQ((*visitor_.object_payload_)[0],
+                  message->PacketSample().substr(i, 1)[0]);
+      }
+    }
+    EXPECT_FALSE(visitor_.end_of_message_);
+  }
+  // Send FIN
+  parser_.ProcessData(absl::string_view(), true);
+  if (message_type_ == MoqtMessageType::kObject) {
+    EXPECT_EQ(visitor_.messages_received_,
+              message->total_message_size() - kObjectPrePayloadSize + 1);
+  } else {
+    EXPECT_EQ(visitor_.messages_received_, 1);
+  }
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.end_of_message_);
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+}
+
+TEST_P(MoqtParserTest, OneByteAtATimeLongerVarints) {
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  message->ExpandVarints();
+  message->set_message_size(0);
+  constexpr size_t kObjectPrePayloadSize = 28;
+  for (size_t i = 0; i < message->total_message_size(); ++i) {
+    parser_.ProcessData(message->PacketSample().substr(i, 1), false);
+    if (message_type_ == MoqtMessageType::kGoAway &&
+        i == message->total_message_size() - 1) {
+      // OnGoAway() is called before FIN.
+      EXPECT_EQ(visitor_.messages_received_, 1);
+      EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+      EXPECT_TRUE(visitor_.end_of_message_);
+      break;
+    }
+    if (message_type_ != MoqtMessageType::kObject ||
+        i < kObjectPrePayloadSize) {
+      // OBJECTs will have to buffer for the first 5 bytes (until the varints
+      // are done). The sixth byte is a bare OBJECT header, so the parser does
+      // not notify the visitor.
+      EXPECT_EQ(visitor_.messages_received_, 0);
+    } else {
+      // OBJECT payload processing.
+      EXPECT_EQ(visitor_.messages_received_, i - kObjectPrePayloadSize + 1);
+      EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+      EXPECT_TRUE(visitor_.object_payload_.has_value());
+      if (i == 5) {
+        EXPECT_EQ(visitor_.object_payload_->length(), 0);
+      } else {
+        EXPECT_EQ(visitor_.object_payload_->length(), 1);
+        EXPECT_EQ((*visitor_.object_payload_)[0],
+                  message->PacketSample().substr(i, 1)[0]);
+      }
+    }
+    EXPECT_FALSE(visitor_.end_of_message_);
+  }
+  // Send FIN
+  parser_.ProcessData(absl::string_view(), true);
+  if (message_type_ == MoqtMessageType::kObject) {
+    EXPECT_EQ(visitor_.messages_received_,
+              message->total_message_size() - kObjectPrePayloadSize + 1);
+  } else {
+    EXPECT_EQ(visitor_.messages_received_, 1);
+  }
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.end_of_message_);
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+}
+
+TEST_P(MoqtParserTest, OneByteAtATimeKnownLength) {
+  std::unique_ptr<TestMessageBase> message = MakeMessage(message_type_);
+  constexpr size_t kObjectPrePayloadSize = 6;
+  // Send all but the last byte
+  for (size_t i = 0; i < message->total_message_size() - 1; ++i) {
+    parser_.ProcessData(message->PacketSample().substr(i, 1), false);
+    if (message_type_ != MoqtMessageType::kObject ||
+        i < kObjectPrePayloadSize) {
+      // OBJECTs will have to buffer for the first 5 bytes (until the varints
+      // are done). The sixth byte is a bare OBJECT header, so the parser does
+      // not notify the visitor.
+      EXPECT_EQ(visitor_.messages_received_, 0);
+    } else {
+      // OBJECT payload processing.
+      EXPECT_EQ(visitor_.messages_received_, i - kObjectPrePayloadSize + 1);
+      EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+      EXPECT_TRUE(visitor_.object_payload_.has_value());
+      if (i == 5) {
+        EXPECT_EQ(visitor_.object_payload_->length(), 0);
+      } else {
+        EXPECT_EQ(visitor_.object_payload_->length(), 1);
+        EXPECT_EQ((*visitor_.object_payload_)[0],
+                  message->PacketSample().substr(i, 1)[0]);
+      }
+    }
+    EXPECT_FALSE(visitor_.end_of_message_);
+  }
+  // Send last byte
+  parser_.ProcessData(
+      message->PacketSample().substr(message->total_message_size() - 1, 1),
+      false);
+  if (message_type_ == MoqtMessageType::kObject) {
+    EXPECT_EQ(visitor_.messages_received_,
+              message->total_message_size() - kObjectPrePayloadSize);
+    EXPECT_EQ(visitor_.object_payload_->length(), 1);
+    EXPECT_EQ((*visitor_.object_payload_)[0],
+              message->PacketSample().substr(message->total_message_size() - 1,
+                                             1)[0]);
+  } else {
+    EXPECT_EQ(visitor_.messages_received_, 1);
+  }
+  EXPECT_TRUE(message->EqualFieldValues(visitor_.last_message_.value()));
+  EXPECT_TRUE(visitor_.end_of_message_);
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+}
+
+TEST_P(MoqtParserTest, LengthTooShort) {
+  if (message_type_ == MoqtMessageType::kGoAway ||
+      message_type_ == MoqtMessageType::kAnnounceOk) {
+    // GOAWAY already has length zero. ANNOUNCE_OK works for any message length.
+    return;
+  }
+  auto message = MakeMessage(message_type_);
+  if (message_type_ == MoqtMessageType::kSetup &&
+      GetParam().perspective == quic::Perspective::IS_CLIENT) {
+    // Unless varints are longer than necessary, the message is only one byte
+    // long.
+    message->ExpandVarints();
+  }
+  size_t truncate = (message_type_ == MoqtMessageType::kObject) ? 4 : 1;
+  message->set_message_size(message->message_size() - truncate);
+  parser_.ProcessData(message->PacketSample(), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "Not able to parse message given specified length");
+}
+
+// Buffered packets are a different code path, so test them separately.
+TEST_P(MoqtParserTest, LengthTooShortInBufferedPacket) {
+  if (message_type_ == MoqtMessageType::kGoAway ||
+      message_type_ == MoqtMessageType::kAnnounceOk) {
+    // GOAWAY already has length zero. ANNOUNCE_OK works for any message length.
+    return;
+  }
+  auto message = MakeMessage(message_type_);
+  if (message_type_ == MoqtMessageType::kSetup &&
+      GetParam().perspective == quic::Perspective::IS_CLIENT) {
+    // Unless varints are longer than necessary, the message is only one byte
+    // long.
+    message->ExpandVarints();
+  }
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  size_t truncate = (message_type_ == MoqtMessageType::kObject) ? 5 : 2;
+  message->set_message_size(message->message_size() - truncate + 1);
+  parser_.ProcessData(
+      message->PacketSample().substr(0, message->total_message_size() - 1),
+      false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_FALSE(visitor_.parsing_error_.has_value());
+  // send the last byte
+  parser_.ProcessData(
+      message->PacketSample().substr(message->total_message_size() - 1, 1),
+      false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "Not able to parse buffered message given specified length");
+}
+
+TEST_P(MoqtParserTest, LengthTooLong) {
+  if (message_type_ == MoqtMessageType::kAnnounceOk ||
+      message_type_ == MoqtMessageType::kObject ||
+      message_type_ == MoqtMessageType::kSetup ||
+      message_type_ == MoqtMessageType::kSubscribeRequest ||
+      message_type_ == MoqtMessageType::kAnnounce) {
+    // OBJECT and ANNOUNCE_OK work for any message length.
+    // SETUP, SUBSCRIBE_REQUEST, and ANNOUNCE have parameters, so an additional
+    // byte will cause the message to be interpreted as being too short.
+    return;
+  }
+  auto message = MakeMessage(message_type_);
+  message->set_message_size(message->message_size() + 1);
+  parser_.ProcessData(message->PacketSample(), false);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  if (message_type_ == MoqtMessageType::kGoAway) {
+    EXPECT_EQ(*visitor_.parsing_error_, "GOAWAY has data following");
+  } else {
+    EXPECT_EQ(*visitor_.parsing_error_, "Specified message length too long");
+  }
+}
+
+TEST_P(MoqtParserTest, LengthExceedsBufferSize) {
+  if (message_type_ == MoqtMessageType::kObject) {
+    // OBJECT works for any length.
+    return;
+  }
+  auto message = MakeMessage(message_type_);
+  message->set_message_size(kMaxMessageHeaderSize + 1);
+  parser_.ProcessData(message->PacketSample(), false);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  if (message_type_ == MoqtMessageType::kGoAway) {
+    EXPECT_EQ(*visitor_.parsing_error_, "GOAWAY has data following");
+  } else {
+    EXPECT_EQ(*visitor_.parsing_error_, "Message too long");
+  }
+}
+
+// Tests for message-specific error cases.
+class MoqtParserErrorTest : public quic::test::QuicTest {
+ public:
+  MoqtParserErrorTest() {}
+
+  MoqtParserTestVisitor visitor_;
+
+  static constexpr bool kWebTrans = true;
+  static constexpr bool kRawQuic = false;
+};
+
+TEST_F(MoqtParserErrorTest, SetupRoleAppearsTwice) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kRawQuic, visitor_);
+  char setup[] = {
+      0x01, 0x0e, 0x02, 0x01, 0x02,  // versions
+      0x00, 0x01, 0x03,              // role = both
+      0x00, 0x01, 0x03,              // role = both
+      0x01, 0x03, 0x66, 0x6f, 0x6f   // path = "foo"
+  };
+  parser.ProcessData(absl::string_view(setup, sizeof(setup)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_, "ROLE parameter appears twice in SETUP");
+}
+
+TEST_F(MoqtParserErrorTest, SetupRoleFromServer) {
+  MoqtParser parser(quic::Perspective::IS_CLIENT, kWebTrans, visitor_);
+  char setup[] = {
+      0x01, 0x04,
+      0x01,              // version = 1
+      0x00, 0x01, 0x03,  // role = both
+  };
+  parser.ProcessData(absl::string_view(setup, sizeof(setup)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_, "ROLE parameter sent by server in SETUP");
+}
+
+TEST_F(MoqtParserErrorTest, SetupRoleIsMissing) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kRawQuic, visitor_);
+  char setup[] = {
+      0x01, 0x08, 0x02, 0x01, 0x02,  // versions = 1, 2
+      0x01, 0x03, 0x66, 0x6f, 0x6f,  // path = "foo"
+  };
+  parser.ProcessData(absl::string_view(setup, sizeof(setup)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "ROLE SETUP parameter missing from Client message");
+}
+
+TEST_F(MoqtParserErrorTest, SetupPathFromServer) {
+  MoqtParser parser(quic::Perspective::IS_CLIENT, kRawQuic, visitor_);
+  char setup[] = {
+      0x01, 0x06,
+      0x01,                          // version = 1
+      0x01, 0x03, 0x66, 0x6f, 0x6f,  // path = "foo"
+  };
+  parser.ProcessData(absl::string_view(setup, sizeof(setup)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_, "PATH parameter sent by server in SETUP");
+}
+
+TEST_F(MoqtParserErrorTest, SetupPathAppearsTwice) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kRawQuic, visitor_);
+  char setup[] = {
+      0x01, 0x10, 0x02, 0x01, 0x02,  // versions = 1, 2
+      0x00, 0x01, 0x03,              // role = both
+      0x01, 0x03, 0x66, 0x6f, 0x6f,  // path = "foo"
+      0x01, 0x03, 0x66, 0x6f, 0x6f,  // path = "foo"
+  };
+  parser.ProcessData(absl::string_view(setup, sizeof(setup)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_, "PATH parameter appears twice in SETUP");
+}
+
+TEST_F(MoqtParserErrorTest, SetupPathOverWebtrans) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kWebTrans, visitor_);
+  char setup[] = {
+      0x01, 0x0b, 0x02, 0x01, 0x02,  // versions = 1, 2
+      0x00, 0x01, 0x03,              // role = both
+      0x01, 0x03, 0x66, 0x6f, 0x6f,  // path = "foo"
+  };
+  parser.ProcessData(absl::string_view(setup, sizeof(setup)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "WebTransport connection is using PATH parameter in SETUP");
+}
+
+TEST_F(MoqtParserErrorTest, SetupPathMissing) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kRawQuic, visitor_);
+  char setup[] = {
+      0x01, 0x06, 0x02, 0x01, 0x02,  // versions = 1, 2
+      0x00, 0x01, 0x03,              // role = both
+  };
+  parser.ProcessData(absl::string_view(setup, sizeof(setup)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "PATH SETUP parameter missing from Client message over QUIC");
+}
+
+TEST_F(MoqtParserErrorTest, SetupRoleTooLong) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kRawQuic, visitor_);
+  char setup[] = {
+      0x01, 0x0e, 0x02, 0x01, 0x02,  // versions
+      // role = both
+      0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01,
+      0x03, 0x66, 0x6f, 0x6f  // path = "foo"
+  };
+  parser.ProcessData(absl::string_view(setup, sizeof(setup)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "Cannot parse explicit length integers longer than 8 bytes");
+}
+
+TEST_F(MoqtParserErrorTest, SubscribeRequestGroupSequenceTwice) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kWebTrans, visitor_);
+  char subscribe_request[] = {
+      0x03, 0x12, 0x03, 0x66, 0x6f, 0x6f,  // track_name = "foo"
+      0x00, 0x01, 0x01,                    // group_sequence = 1
+      0x00, 0x01, 0x01,                    // group_sequence = 1
+      0x01, 0x01, 0x02,                    // object_sequence = 2
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+  };
+  parser.ProcessData(
+      absl::string_view(subscribe_request, sizeof(subscribe_request)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "GROUP_SEQUENCE parameter appears twice in SUBSCRIBE_REQUEST");
+}
+
+TEST_F(MoqtParserErrorTest, SubscribeRequestObjectSequenceTwice) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kWebTrans, visitor_);
+  char subscribe_request[] = {
+      0x03, 0x12, 0x03, 0x66, 0x6f, 0x6f,  // track_name = "foo"
+      0x00, 0x01, 0x01,                    // group_sequence = 1
+      0x01, 0x01, 0x02,                    // object_sequence = 2
+      0x01, 0x01, 0x02,                    // object_sequence = 2
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+  };
+  parser.ProcessData(
+      absl::string_view(subscribe_request, sizeof(subscribe_request)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "OBJECT_SEQUENCE parameter appears twice in SUBSCRIBE_REQUEST");
+}
+
+TEST_F(MoqtParserErrorTest, SubscribeRequestAuthorizationInfoTwice) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kWebTrans, visitor_);
+  char subscribe_request[] = {
+      0x03, 0x14, 0x03, 0x66, 0x6f, 0x6f,  // track_name = "foo"
+      0x00, 0x01, 0x01,                    // group_sequence = 1
+      0x01, 0x01, 0x02,                    // object_sequence = 2
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+  };
+  parser.ProcessData(
+      absl::string_view(subscribe_request, sizeof(subscribe_request)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "AUTHORIZATION_INFO parameter appears twice in SUBSCRIBE_REQUEST");
+}
+
+TEST_F(MoqtParserErrorTest, AnnounceGroupSequenceTwice) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kWebTrans, visitor_);
+  char announce[] = {
+      0x06, 0x0f, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace = "foo"
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+      0x00, 0x01, 0x01,                    // group_sequence = 1
+      0x00, 0x01, 0x01,                    // group_sequence = 1
+  };
+  parser.ProcessData(absl::string_view(announce, sizeof(announce)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "GROUP_SEQUENCE parameter appears twice in ANNOUNCE");
+}
+
+TEST_F(MoqtParserErrorTest, AnnounceObjectSequenceTwice) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kWebTrans, visitor_);
+  char announce[] = {
+      0x06, 0x0e, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace = "foo"
+      0x01, 0x01, 0x02,                    // object_sequence = 2
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+      0x01, 0x01, 0x02,                    // object_sequence = 2
+  };
+  parser.ProcessData(absl::string_view(announce, sizeof(announce)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "OBJECT_SEQUENCE parameter appears twice in ANNOUNCE");
+}
+
+TEST_F(MoqtParserErrorTest, AnnounceAuthorizationInfoTwice) {
+  MoqtParser parser(quic::Perspective::IS_SERVER, kWebTrans, visitor_);
+  char announce[] = {
+      0x06, 0x0e, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace = "foo"
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+  };
+  parser.ProcessData(absl::string_view(announce, sizeof(announce)), false);
+  EXPECT_EQ(visitor_.messages_received_, 0);
+  EXPECT_TRUE(visitor_.parsing_error_.has_value());
+  EXPECT_EQ(*visitor_.parsing_error_,
+            "AUTHORIZATION_INFO parameter appears twice in ANNOUNCE");
+}
+
+}  // namespace moqt::test
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
new file mode 100644
index 0000000..aa4c8c0
--- /dev/null
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -0,0 +1,526 @@
+// Copyright (c) 2023 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.
+
+#ifndef QUICHE_QUIC_MOQT_TEST_TOOLS_MOQT_TEST_MESSAGE_H_
+#define QUICHE_QUIC_MOQT_TEST_TOOLS_MOQT_TEST_MESSAGE_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <vector>
+
+#include "absl/strings/string_view.h"
+#include "absl/types/optional.h"
+#include "absl/types/variant.h"
+#include "quiche/quic/core/quic_data_reader.h"
+#include "quiche/quic/core/quic_data_writer.h"
+#include "quiche/quic/core/quic_time.h"
+#include "quiche/quic/moqt/moqt_messages.h"
+#include "quiche/quic/platform/api/quic_logging.h"
+#include "quiche/quic/platform/api/quic_test.h"
+#include "quiche/common/platform/api/quiche_export.h"
+#include "quiche/common/quiche_endian.h"
+
+namespace moqt::test {
+
+// Base class containing a wire image and the corresponding structured
+// representation of an example of each message. It allows parser and framer
+// tests to iterate through all message types without much specialized code.
+class QUICHE_NO_EXPORT TestMessageBase {
+ public:
+  TestMessageBase(MoqtMessageType message_type) : message_type_(message_type) {}
+  virtual ~TestMessageBase() = default;
+  MoqtMessageType message_type() const { return message_type_; }
+
+  typedef absl::variant<MoqtSetup, MoqtObject, MoqtSubscribeRequest,
+                        MoqtSubscribeOk, MoqtSubscribeError, MoqtAnnounce,
+                        MoqtAnnounceOk, MoqtAnnounceError, MoqtGoAway>
+      MessageStructuredData;
+
+  // The total actual size of the message.
+  size_t total_message_size() const { return wire_image_size_; }
+
+  // The message size indicated in the second varint in every message.
+  size_t message_size() const {
+    quic::QuicDataReader reader(PacketSample());
+    uint64_t value;
+    if (!reader.ReadVarInt62(&value)) {
+      return 0;
+    }
+    if (!reader.ReadVarInt62(&value)) {
+      return 0;
+    }
+    return value;
+  }
+
+  absl::string_view PacketSample() const {
+    return absl::string_view(wire_image_, wire_image_size_);
+  }
+
+  void set_wire_image_size(size_t wire_image_size) {
+    wire_image_size_ = wire_image_size;
+  }
+
+  // Sets the message length field. If |message_size| == 0, just change the
+  // field in the wire image. If another value, this will either truncate the
+  // message or increase its length (which adds uninitialized bytes). This can
+  // be useful for playing with different Object Payload lengths, for example.
+  void set_message_size(uint64_t message_size) {
+    char new_wire_image[sizeof(wire_image_)];
+    quic::QuicDataReader reader(PacketSample());
+    quic::QuicDataWriter writer(sizeof(new_wire_image), new_wire_image);
+    uint64_t type;
+    auto field_size = reader.PeekVarInt62Length();
+    reader.ReadVarInt62(&type);
+    writer.WriteVarInt62WithForcedLength(
+        type, std::max(field_size, writer.GetVarInt62Len(type)));
+    uint64_t original_length;
+    field_size = reader.PeekVarInt62Length();
+    reader.ReadVarInt62(&original_length);
+    // Try to preserve the original field length, unless it's too small.
+    writer.WriteVarInt62WithForcedLength(
+        message_size,
+        std::max(field_size, writer.GetVarInt62Len(message_size)));
+    writer.WriteStringPiece(reader.PeekRemainingPayload());
+    memcpy(wire_image_, new_wire_image, writer.length());
+    wire_image_size_ = writer.length();
+    if (message_size > original_length) {
+      wire_image_size_ += (message_size - original_length);
+    }
+    if (message_size > 0 && message_size < original_length) {
+      wire_image_size_ -= (original_length - message_size);
+    }
+  }
+
+  // Compares |values| to the derived class's structured data to make sure
+  // they are equal.
+  virtual bool EqualFieldValues(MessageStructuredData& values) const = 0;
+
+  // Expand all varints in the message. This is pure virtual because each
+  // message has a different layout of varints.
+  virtual void ExpandVarints() = 0;
+
+ protected:
+  void SetWireImage(uint8_t* wire_image, size_t wire_image_size) {
+    memcpy(wire_image_, wire_image, wire_image_size);
+    wire_image_size_ = wire_image_size;
+  }
+
+  // Expands all the varints in the message, alternating between making them 2,
+  // 4, and 8 bytes long. Updates length fields accordingly.
+  // Each character in |varints| corresponds to a byte in the original message.
+  // If there is a 'v', it is a varint that should be expanded. If '-', skip
+  // to the next byte.
+  void ExpandVarintsImpl(absl::string_view varints) {
+    int next_varint_len = 2;
+    char new_wire_image[kMaxMessageHeaderSize + 1];
+    quic::QuicDataReader reader(
+        absl::string_view(wire_image_, wire_image_size_));
+    quic::QuicDataWriter writer(sizeof(new_wire_image), new_wire_image);
+    size_t message_length = 0;
+    int item = 0;
+    size_t i = 0;
+    while (!reader.IsDoneReading()) {
+      if (i >= varints.length() || varints[i++] == '-') {
+        uint8_t byte;
+        reader.ReadUInt8(&byte);
+        writer.WriteUInt8(byte);
+        continue;
+      }
+      uint64_t value;
+      item++;
+      reader.ReadVarInt62(&value);
+      writer.WriteVarInt62WithForcedLength(
+          value, static_cast<quiche::QuicheVariableLengthIntegerLength>(
+                     next_varint_len));
+      if (item == 2) {
+        // this is the message length field.
+        message_length = value;
+      }
+      next_varint_len *= 2;
+      if (next_varint_len == 16) {
+        next_varint_len = 2;
+      }
+    }
+    if (message_length > 0) {
+      // Update message length. Based on the progression of next_varint_len,
+      // the message_type is 2 bytes and message_length is 4 bytes.
+      message_length = writer.length() - 6;
+      auto new_writer = quic::QuicDataWriter(4, (char*)&new_wire_image[2]);
+      new_writer.WriteVarInt62WithForcedLength(
+          message_length,
+          static_cast<quiche::QuicheVariableLengthIntegerLength>(4));
+    }
+    memcpy(wire_image_, new_wire_image, writer.length());
+    wire_image_size_ = writer.length();
+  }
+
+ private:
+  MoqtMessageType message_type_;
+  char wire_image_[kMaxMessageHeaderSize + 20];
+  size_t wire_image_size_;
+};
+
+class QUICHE_NO_EXPORT ObjectMessage : public TestMessageBase {
+ public:
+  ObjectMessage() : TestMessageBase(MoqtMessageType::kObject) {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtObject>(values);
+    if (cast.track_id != object_.track_id) {
+      QUIC_LOG(INFO) << "OBJECT Track ID mismatch";
+      return false;
+    }
+    if (cast.group_sequence != object_.group_sequence) {
+      QUIC_LOG(INFO) << "OBJECT Group Sequence mismatch";
+      return false;
+    }
+    if (cast.object_sequence != object_.object_sequence) {
+      QUIC_LOG(INFO) << "OBJECT Object Sequence mismatch";
+      return false;
+    }
+    if (cast.object_send_order != object_.object_send_order) {
+      QUIC_LOG(INFO) << "OBJECT Object Send Order mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override {
+    ExpandVarintsImpl("vvvvvv");  // first six fields are varints
+  }
+
+ private:
+  uint8_t raw_packet_[9] = {
+      0x00, 0x07, 0x04, 0x05, 0x06, 0x07,  // varints
+      0x66, 0x6f, 0x6f,                    // payload = "foo"
+  };
+  MoqtObject object_ = {
+      /*track_id=*/4,
+      /*group_sequence=*/5,
+      /*object_sequence=*/6,
+      /*object_send_order=*/7,
+  };
+};
+
+class QUICHE_NO_EXPORT SetupMessage : public TestMessageBase {
+ public:
+  explicit SetupMessage(bool client_parser, bool webtrans)
+      : TestMessageBase(MoqtMessageType::kSetup), client_(client_parser) {
+    if (client_parser) {
+      SetWireImage(server_raw_packet_, sizeof(server_raw_packet_));
+    } else {
+      SetWireImage(client_raw_packet_, sizeof(client_raw_packet_));
+      if (webtrans) {
+        // Should not send PATH.
+        set_message_size(message_size() - 5);
+        client_setup_.path = absl::nullopt;
+      }
+    }
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtSetup>(values);
+    const MoqtSetup* compare = client_ ? &server_setup_ : &client_setup_;
+    if (cast.number_of_supported_versions !=
+        compare->number_of_supported_versions) {
+      QUIC_LOG(INFO) << "SETUP number of supported versions mismatch";
+      return false;
+    }
+    for (uint64_t i = 0; i < cast.number_of_supported_versions; ++i) {
+      // Listed versions are 1 and 2, in that order.
+      if (cast.supported_versions[i] != compare->supported_versions[i]) {
+        QUIC_LOG(INFO) << "SETUP supported version mismatch";
+        return false;
+      }
+    }
+    if (cast.role != compare->role) {
+      QUIC_LOG(INFO) << "SETUP role mismatch";
+      return false;
+    }
+    if (cast.path != compare->path) {
+      QUIC_LOG(INFO) << "SETUP path mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override {
+    if (client_) {
+      ExpandVarintsImpl("vvvvvvv-vv---");  // skip one byte for Role value
+    } else {
+      ExpandVarintsImpl("vvv");  // all three are varints
+    }
+  }
+
+ private:
+  bool client_;
+  uint8_t client_raw_packet_[13] = {
+      0x01, 0x0b, 0x02, 0x01, 0x02,  // versions
+      0x00, 0x01, 0x03,              // role = both
+      0x01, 0x03, 0x66, 0x6f, 0x6f   //  path = "foo"
+  };
+  uint8_t server_raw_packet_[3] = {
+      0x01, 0x01,
+      0x01,  // version
+  };
+  MoqtSetup client_setup_ = {
+      /*number_of_supported_versions=*/2,
+      /*supported_versions=*/std::vector<uint64_t>({1, 2}),
+      /*role=*/MoqtRole::kBoth,
+      /*path=*/"foo",
+  };
+  MoqtSetup server_setup_ = {
+      /*number_of_supported_versions=*/1,
+      /*supported_versions=*/std::vector<uint64_t>({1}),
+      /*role=*/absl::nullopt,
+      /*path=*/absl::nullopt,
+  };
+};
+
+class QUICHE_NO_EXPORT SubscribeRequestMessage : public TestMessageBase {
+ public:
+  SubscribeRequestMessage()
+      : TestMessageBase(MoqtMessageType::kSubscribeRequest) {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtSubscribeRequest>(values);
+    if (cast.full_track_name != subscribe_request_.full_track_name) {
+      QUIC_LOG(INFO) << "SUBSCRIBE REQUEST full track name mismatch";
+      return false;
+    }
+    if (cast.group_sequence != subscribe_request_.group_sequence) {
+      QUIC_LOG(INFO) << "SUBSCRIBE REQUEST group sequence mismatch";
+      return false;
+    }
+    if (cast.object_sequence != subscribe_request_.object_sequence) {
+      QUIC_LOG(INFO) << "SUBSCRIBE REQUEST object sequence mismatch";
+      return false;
+    }
+    if (cast.authorization_info != subscribe_request_.authorization_info) {
+      QUIC_LOG(INFO) << "SUBSCRIBE REQUEST authorization info mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---vv-vv-vv"); }
+
+ private:
+  uint8_t raw_packet_[17] = {
+      0x03, 0x0f, 0x03, 0x66, 0x6f, 0x6f,  // track_name = "foo"
+      0x00, 0x01, 0x01,                    // group_sequence = 1
+      0x01, 0x01, 0x02,                    // object_sequence = 2
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+  };
+
+  MoqtSubscribeRequest subscribe_request_ = {
+      /*full_track_name=*/"foo",
+      /*group_sequence=*/1,
+      /*object_sequence=*/2,
+      /*authorization_info=*/"bar",
+  };
+};
+
+class QUICHE_NO_EXPORT SubscribeOkMessage : public TestMessageBase {
+ public:
+  SubscribeOkMessage() : TestMessageBase(MoqtMessageType::kSubscribeOk) {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtSubscribeOk>(values);
+    if (cast.full_track_name != subscribe_ok_.full_track_name) {
+      return false;
+    }
+    if (cast.track_id != subscribe_ok_.track_id) {
+      return false;
+    }
+    if (cast.expires != subscribe_ok_.expires) {
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---vv"); }
+
+ private:
+  uint8_t raw_packet_[8] = {
+      0x04, 0x06, 0x03, 0x66, 0x6f, 0x6f,  // track_name = "foo"
+      0x01,                                // track_id = 1
+      0x02,                                // expires = 2
+  };
+
+  MoqtSubscribeOk subscribe_ok_ = {
+      /*full_track_name=*/"foo",
+      /*track_id=*/1,
+      /*expires=*/quic::QuicTimeDelta::FromMilliseconds(2),
+  };
+};
+
+class QUICHE_NO_EXPORT SubscribeErrorMessage : public TestMessageBase {
+ public:
+  SubscribeErrorMessage() : TestMessageBase(MoqtMessageType::kSubscribeError) {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtSubscribeError>(values);
+    if (cast.full_track_name != subscribe_error_.full_track_name) {
+      QUIC_LOG(INFO) << "SUBSCRIBE ERROR full track name mismatch";
+      return false;
+    }
+    if (cast.error_code != subscribe_error_.error_code) {
+      QUIC_LOG(INFO) << "SUBSCRIBE ERROR error code mismatch";
+      return false;
+    }
+    if (cast.reason_phrase != subscribe_error_.reason_phrase) {
+      QUIC_LOG(INFO) << "SUBSCRIBE ERROR reason phrase mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---vv---"); }
+
+ private:
+  uint8_t raw_packet_[11] = {
+      0x05, 0x09, 0x03, 0x66, 0x6f, 0x6f,  // track_name = "foo"
+      0x01,                                // error_code = 1
+      0x03, 0x62, 0x61, 0x72,              // reason_phrase = "bar"
+  };
+
+  MoqtSubscribeError subscribe_error_ = {
+      /*full_track_name=*/"foo",
+      /*subscribe=*/1,
+      /*reason_phrase=*/"bar",
+  };
+};
+
+class QUICHE_NO_EXPORT AnnounceMessage : public TestMessageBase {
+ public:
+  AnnounceMessage() : TestMessageBase(MoqtMessageType::kAnnounce) {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtAnnounce>(values);
+    if (cast.track_namespace != announce_.track_namespace) {
+      QUIC_LOG(INFO) << "ANNOUNCE MESSAGE track namespace mismatch";
+      return false;
+    }
+    if (cast.authorization_info != announce_.authorization_info) {
+      QUIC_LOG(INFO) << "ANNOUNCE MESSAGE authorization info mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---vv---"); }
+
+ private:
+  uint8_t raw_packet_[11] = {
+      0x06, 0x09, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace = "foo"
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+  };
+
+  MoqtAnnounce announce_ = {
+      /*track_namespace=*/"foo",
+      /*authorization_info=*/"bar",
+  };
+};
+
+class QUICHE_NO_EXPORT AnnounceOkMessage : public TestMessageBase {
+ public:
+  AnnounceOkMessage() : TestMessageBase(MoqtMessageType::kAnnounceOk) {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtAnnounceOk>(values);
+    if (cast.track_namespace != announce_ok_.track_namespace) {
+      QUIC_LOG(INFO) << "ANNOUNCE OK MESSAGE track namespace mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vv---"); }
+
+ private:
+  uint8_t raw_packet_[5] = {
+      0x07, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace = "foo"
+  };
+
+  MoqtAnnounceOk announce_ok_ = {
+      /*track_namespace=*/"foo",
+  };
+};
+
+class QUICHE_NO_EXPORT AnnounceErrorMessage : public TestMessageBase {
+ public:
+  AnnounceErrorMessage() : TestMessageBase(MoqtMessageType::kAnnounceError) {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtAnnounceError>(values);
+    if (cast.track_namespace != announce_error_.track_namespace) {
+      QUIC_LOG(INFO) << "ANNOUNCE ERROR track namespace mismatch";
+      return false;
+    }
+    if (cast.error_code != announce_error_.error_code) {
+      QUIC_LOG(INFO) << "ANNOUNCE ERROR error code mismatch";
+      return false;
+    }
+    if (cast.reason_phrase != announce_error_.reason_phrase) {
+      QUIC_LOG(INFO) << "ANNOUNCE ERROR reason phrase mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---vv---"); }
+
+ private:
+  uint8_t raw_packet_[11] = {
+      0x08, 0x09, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace = "foo"
+      0x01,                                // error__code = 1
+      0x03, 0x62, 0x61, 0x72,              // reason_phrase = "bar"
+  };
+
+  MoqtAnnounceError announce_error_ = {
+      /*track_namespace=*/"foo",
+      /*error_code=*/1,
+      /*reason_phrase=*/"bar",
+  };
+};
+
+class QUICHE_NO_EXPORT GoAwayMessage : public TestMessageBase {
+ public:
+  GoAwayMessage() : TestMessageBase(MoqtMessageType::kGoAway) {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& /*values*/) const override {
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vv"); }
+
+ private:
+  uint8_t raw_packet_[2] = {
+      0x10,
+      0x00,
+  };
+};
+
+}  // namespace moqt::test
+
+#endif  // QUICHE_QUIC_MOQT_TEST_TOOLS_MOQT_TEST_MESSAGE_H_