diff --git a/quiche/quic/moqt/moqt_framer.cc b/quiche/quic/moqt/moqt_framer.cc
index f17caf8..074c2be 100644
--- a/quiche/quic/moqt/moqt_framer.cc
+++ b/quiche/quic/moqt/moqt_framer.cc
@@ -581,6 +581,33 @@
                    WireStringWithVarInt62Length(message.new_session_uri));
 }
 
+quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespace(
+    const MoqtSubscribeNamespace& message) {
+  return Serialize(WireVarInt62(MoqtMessageType::kSubscribeNamespace),
+                   WireFullTrackName(message.track_namespace, false),
+                   WireSubscribeParameterList(message.parameters));
+}
+
+quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespaceOk(
+    const MoqtSubscribeNamespaceOk& message) {
+  return Serialize(WireVarInt62(MoqtMessageType::kSubscribeNamespaceOk),
+                   WireFullTrackName(message.track_namespace, false));
+}
+
+quiche::QuicheBuffer MoqtFramer::SerializeSubscribeNamespaceError(
+    const MoqtSubscribeNamespaceError& message) {
+  return Serialize(WireVarInt62(MoqtMessageType::kSubscribeNamespaceError),
+                   WireFullTrackName(message.track_namespace, false),
+                   WireVarInt62(message.error_code),
+                   WireStringWithVarInt62Length(message.reason_phrase));
+}
+
+quiche::QuicheBuffer MoqtFramer::SerializeUnsubscribeNamespace(
+    const MoqtUnsubscribeNamespace& message) {
+  return Serialize(WireVarInt62(MoqtMessageType::kUnsubscribeNamespace),
+                   WireFullTrackName(message.track_namespace, false));
+}
+
 quiche::QuicheBuffer MoqtFramer::SerializeMaxSubscribeId(
     const MoqtMaxSubscribeId& message) {
   return Serialize(WireVarInt62(MoqtMessageType::kMaxSubscribeId),
diff --git a/quiche/quic/moqt/moqt_framer.h b/quiche/quic/moqt/moqt_framer.h
index b18a77c..78b9cf3 100644
--- a/quiche/quic/moqt/moqt_framer.h
+++ b/quiche/quic/moqt/moqt_framer.h
@@ -55,6 +55,14 @@
   quiche::QuicheBuffer SerializeUnannounce(const MoqtUnannounce& message);
   quiche::QuicheBuffer SerializeTrackStatus(const MoqtTrackStatus& message);
   quiche::QuicheBuffer SerializeGoAway(const MoqtGoAway& message);
+  quiche::QuicheBuffer SerializeSubscribeNamespace(
+      const MoqtSubscribeNamespace& message);
+  quiche::QuicheBuffer SerializeSubscribeNamespaceOk(
+      const MoqtSubscribeNamespaceOk& message);
+  quiche::QuicheBuffer SerializeSubscribeNamespaceError(
+      const MoqtSubscribeNamespaceError& message);
+  quiche::QuicheBuffer SerializeUnsubscribeNamespace(
+      const MoqtUnsubscribeNamespace& message);
   quiche::QuicheBuffer SerializeMaxSubscribeId(
       const MoqtMaxSubscribeId& message);
   quiche::QuicheBuffer SerializeObjectAck(const MoqtObjectAck& message);
diff --git a/quiche/quic/moqt/moqt_framer_test.cc b/quiche/quic/moqt/moqt_framer_test.cc
index be6ae32..5ed05c1 100644
--- a/quiche/quic/moqt/moqt_framer_test.cc
+++ b/quiche/quic/moqt/moqt_framer_test.cc
@@ -46,6 +46,10 @@
       MoqtMessageType::kAnnounceError,
       MoqtMessageType::kUnannounce,
       MoqtMessageType::kGoAway,
+      MoqtMessageType::kSubscribeNamespace,
+      MoqtMessageType::kSubscribeNamespaceOk,
+      MoqtMessageType::kSubscribeNamespaceError,
+      MoqtMessageType::kUnsubscribeNamespace,
       MoqtMessageType::kMaxSubscribeId,
       MoqtMessageType::kObjectAck,
       MoqtMessageType::kClientSetup,
@@ -158,6 +162,22 @@
         auto data = std::get<MoqtGoAway>(structured_data);
         return framer_.SerializeGoAway(data);
       }
+      case moqt::MoqtMessageType::kSubscribeNamespace: {
+        auto data = std::get<MoqtSubscribeNamespace>(structured_data);
+        return framer_.SerializeSubscribeNamespace(data);
+      }
+      case moqt::MoqtMessageType::kSubscribeNamespaceOk: {
+        auto data = std::get<MoqtSubscribeNamespaceOk>(structured_data);
+        return framer_.SerializeSubscribeNamespaceOk(data);
+      }
+      case moqt::MoqtMessageType::kSubscribeNamespaceError: {
+        auto data = std::get<MoqtSubscribeNamespaceError>(structured_data);
+        return framer_.SerializeSubscribeNamespaceError(data);
+      }
+      case moqt::MoqtMessageType::kUnsubscribeNamespace: {
+        auto data = std::get<MoqtUnsubscribeNamespace>(structured_data);
+        return framer_.SerializeUnsubscribeNamespace(data);
+      }
       case moqt::MoqtMessageType::kMaxSubscribeId: {
         auto data = std::get<MoqtMaxSubscribeId>(structured_data);
         return framer_.SerializeMaxSubscribeId(data);
diff --git a/quiche/quic/moqt/moqt_messages.h b/quiche/quic/moqt/moqt_messages.h
index 57c26ab..b5816d8 100644
--- a/quiche/quic/moqt/moqt_messages.h
+++ b/quiche/quic/moqt/moqt_messages.h
@@ -489,6 +489,25 @@
   std::string new_session_uri;
 };
 
+struct QUICHE_EXPORT MoqtSubscribeNamespace {
+  FullTrackName track_namespace;
+  MoqtSubscribeParameters parameters;
+};
+
+struct QUICHE_EXPORT MoqtSubscribeNamespaceOk {
+  FullTrackName track_namespace;
+};
+
+struct QUICHE_EXPORT MoqtSubscribeNamespaceError {
+  FullTrackName track_namespace;
+  MoqtAnnounceErrorCode error_code;
+  std::string reason_phrase;
+};
+
+struct QUICHE_EXPORT MoqtUnsubscribeNamespace {
+  FullTrackName track_namespace;
+};
+
 struct QUICHE_EXPORT MoqtMaxSubscribeId {
   uint64_t max_subscribe_id;
 };
diff --git a/quiche/quic/moqt/moqt_parser.cc b/quiche/quic/moqt/moqt_parser.cc
index 51658d4..2140748 100644
--- a/quiche/quic/moqt/moqt_parser.cc
+++ b/quiche/quic/moqt/moqt_parser.cc
@@ -8,7 +8,6 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstring>
-#include <initializer_list>
 #include <optional>
 #include <string>
 
@@ -229,6 +228,14 @@
       return ProcessTrackStatus(reader);
     case MoqtMessageType::kGoAway:
       return ProcessGoAway(reader);
+    case MoqtMessageType::kSubscribeNamespace:
+      return ProcessSubscribeNamespace(reader);
+    case MoqtMessageType::kSubscribeNamespaceOk:
+      return ProcessSubscribeNamespaceOk(reader);
+    case MoqtMessageType::kSubscribeNamespaceError:
+      return ProcessSubscribeNamespaceError(reader);
+    case MoqtMessageType::kUnsubscribeNamespace:
+      return ProcessUnsubscribeNamespace(reader);
     case MoqtMessageType::kMaxSubscribeId:
       return ProcessMaxSubscribeId(reader);
     case moqt::MoqtMessageType::kObjectAck:
@@ -706,6 +713,54 @@
   return reader.PreviouslyReadPayload().length();
 }
 
+size_t MoqtControlParser::ProcessSubscribeNamespace(
+    quic::QuicDataReader& reader) {
+  MoqtSubscribeNamespace subscribe_namespace;
+  if (!ReadTrackNamespace(reader, subscribe_namespace.track_namespace)) {
+    return 0;
+  }
+  if (!ReadSubscribeParameters(reader, subscribe_namespace.parameters)) {
+    return 0;
+  }
+  visitor_.OnSubscribeNamespaceMessage(subscribe_namespace);
+  return reader.PreviouslyReadPayload().length();
+}
+
+size_t MoqtControlParser::ProcessSubscribeNamespaceOk(
+    quic::QuicDataReader& reader) {
+  MoqtSubscribeNamespaceOk subscribe_namespace_ok;
+  if (!ReadTrackNamespace(reader, subscribe_namespace_ok.track_namespace)) {
+    return 0;
+  }
+  visitor_.OnSubscribeNamespaceOkMessage(subscribe_namespace_ok);
+  return reader.PreviouslyReadPayload().length();
+}
+
+size_t MoqtControlParser::ProcessSubscribeNamespaceError(
+    quic::QuicDataReader& reader) {
+  MoqtSubscribeNamespaceError subscribe_namespace_error;
+  uint64_t error_code;
+  if (!ReadTrackNamespace(reader, subscribe_namespace_error.track_namespace) ||
+      !reader.ReadVarInt62(&error_code) ||
+      !reader.ReadStringVarInt62(subscribe_namespace_error.reason_phrase)) {
+    return 0;
+  }
+  subscribe_namespace_error.error_code =
+      static_cast<MoqtAnnounceErrorCode>(error_code);
+  visitor_.OnSubscribeNamespaceErrorMessage(subscribe_namespace_error);
+  return reader.PreviouslyReadPayload().length();
+}
+
+size_t MoqtControlParser::ProcessUnsubscribeNamespace(
+    quic::QuicDataReader& reader) {
+  MoqtUnsubscribeNamespace unsubscribe_namespace;
+  if (!ReadTrackNamespace(reader, unsubscribe_namespace.track_namespace)) {
+    return 0;
+  }
+  visitor_.OnUnsubscribeNamespaceMessage(unsubscribe_namespace);
+  return reader.PreviouslyReadPayload().length();
+}
+
 size_t MoqtControlParser::ProcessMaxSubscribeId(quic::QuicDataReader& reader) {
   MoqtMaxSubscribeId max_subscribe_id;
   if (!reader.ReadVarInt62(&max_subscribe_id.max_subscribe_id)) {
diff --git a/quiche/quic/moqt/moqt_parser.h b/quiche/quic/moqt/moqt_parser.h
index 876b27a..5f180b5 100644
--- a/quiche/quic/moqt/moqt_parser.h
+++ b/quiche/quic/moqt/moqt_parser.h
@@ -43,6 +43,14 @@
   virtual void OnUnannounceMessage(const MoqtUnannounce& message) = 0;
   virtual void OnTrackStatusMessage(const MoqtTrackStatus& message) = 0;
   virtual void OnGoAwayMessage(const MoqtGoAway& message) = 0;
+  virtual void OnSubscribeNamespaceMessage(
+      const MoqtSubscribeNamespace& message) = 0;
+  virtual void OnSubscribeNamespaceOkMessage(
+      const MoqtSubscribeNamespaceOk& message) = 0;
+  virtual void OnSubscribeNamespaceErrorMessage(
+      const MoqtSubscribeNamespaceError& message) = 0;
+  virtual void OnUnsubscribeNamespaceMessage(
+      const MoqtUnsubscribeNamespace& message) = 0;
   virtual void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) = 0;
   virtual void OnObjectAckMessage(const MoqtObjectAck& message) = 0;
 
@@ -108,6 +116,10 @@
   size_t ProcessUnannounce(quic::QuicDataReader& reader);
   size_t ProcessTrackStatus(quic::QuicDataReader& reader);
   size_t ProcessGoAway(quic::QuicDataReader& reader);
+  size_t ProcessSubscribeNamespace(quic::QuicDataReader& reader);
+  size_t ProcessSubscribeNamespaceOk(quic::QuicDataReader& reader);
+  size_t ProcessSubscribeNamespaceError(quic::QuicDataReader& reader);
+  size_t ProcessUnsubscribeNamespace(quic::QuicDataReader& reader);
   size_t ProcessMaxSubscribeId(quic::QuicDataReader& reader);
   size_t ProcessObjectAck(quic::QuicDataReader& reader);
 
diff --git a/quiche/quic/moqt/moqt_parser_test.cc b/quiche/quic/moqt/moqt_parser_test.cc
index 6c34083..5c1d028 100644
--- a/quiche/quic/moqt/moqt_parser_test.cc
+++ b/quiche/quic/moqt/moqt_parser_test.cc
@@ -31,15 +31,28 @@
 using ::testing::Optional;
 
 constexpr std::array kMessageTypes{
-    MoqtMessageType::kSubscribe,      MoqtMessageType::kSubscribeOk,
-    MoqtMessageType::kSubscribeError, MoqtMessageType::kSubscribeUpdate,
-    MoqtMessageType::kUnsubscribe,    MoqtMessageType::kSubscribeDone,
-    MoqtMessageType::kAnnounceCancel, MoqtMessageType::kTrackStatusRequest,
-    MoqtMessageType::kTrackStatus,    MoqtMessageType::kAnnounce,
-    MoqtMessageType::kAnnounceOk,     MoqtMessageType::kAnnounceError,
-    MoqtMessageType::kUnannounce,     MoqtMessageType::kClientSetup,
-    MoqtMessageType::kServerSetup,    MoqtMessageType::kGoAway,
-    MoqtMessageType::kMaxSubscribeId, MoqtMessageType::kObjectAck,
+    MoqtMessageType::kSubscribe,
+    MoqtMessageType::kSubscribeOk,
+    MoqtMessageType::kSubscribeError,
+    MoqtMessageType::kSubscribeUpdate,
+    MoqtMessageType::kUnsubscribe,
+    MoqtMessageType::kSubscribeDone,
+    MoqtMessageType::kAnnounceCancel,
+    MoqtMessageType::kTrackStatusRequest,
+    MoqtMessageType::kTrackStatus,
+    MoqtMessageType::kAnnounce,
+    MoqtMessageType::kAnnounceOk,
+    MoqtMessageType::kAnnounceError,
+    MoqtMessageType::kUnannounce,
+    MoqtMessageType::kClientSetup,
+    MoqtMessageType::kServerSetup,
+    MoqtMessageType::kGoAway,
+    MoqtMessageType::kSubscribeNamespace,
+    MoqtMessageType::kSubscribeNamespaceOk,
+    MoqtMessageType::kSubscribeNamespaceError,
+    MoqtMessageType::kUnsubscribeNamespace,
+    MoqtMessageType::kMaxSubscribeId,
+    MoqtMessageType::kObjectAck,
 };
 constexpr std::array kDataStreamTypes{
     MoqtDataStreamType::kStreamHeaderTrack,
@@ -162,6 +175,22 @@
   void OnGoAwayMessage(const MoqtGoAway& message) override {
     OnControlMessage(message);
   }
+  void OnSubscribeNamespaceMessage(
+      const MoqtSubscribeNamespace& message) override {
+    OnControlMessage(message);
+  }
+  void OnSubscribeNamespaceOkMessage(
+      const MoqtSubscribeNamespaceOk& message) override {
+    OnControlMessage(message);
+  }
+  void OnSubscribeNamespaceErrorMessage(
+      const MoqtSubscribeNamespaceError& message) override {
+    OnControlMessage(message);
+  }
+  void OnUnsubscribeNamespaceMessage(
+      const MoqtUnsubscribeNamespace& message) override {
+    OnControlMessage(message);
+  }
   void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) override {
     OnControlMessage(message);
   }
diff --git a/quiche/quic/moqt/moqt_session.h b/quiche/quic/moqt/moqt_session.h
index ecfe8d0..dbf0186 100644
--- a/quiche/quic/moqt/moqt_session.h
+++ b/quiche/quic/moqt/moqt_session.h
@@ -204,6 +204,14 @@
     void OnUnannounceMessage(const MoqtUnannounce& /*message*/) override {}
     void OnTrackStatusMessage(const MoqtTrackStatus& message) override {}
     void OnGoAwayMessage(const MoqtGoAway& /*message*/) override {}
+    void OnSubscribeNamespaceMessage(
+        const MoqtSubscribeNamespace& message) override {}
+    void OnSubscribeNamespaceOkMessage(
+        const MoqtSubscribeNamespaceOk& message) override {}
+    void OnSubscribeNamespaceErrorMessage(
+        const MoqtSubscribeNamespaceError& message) override {}
+    void OnUnsubscribeNamespaceMessage(
+        const MoqtUnsubscribeNamespace& message) override {}
     void OnMaxSubscribeIdMessage(const MoqtMaxSubscribeId& message) override;
     void OnObjectAckMessage(const MoqtObjectAck& message) override {
       auto subscription_it =
diff --git a/quiche/quic/moqt/test_tools/moqt_test_message.h b/quiche/quic/moqt/test_tools/moqt_test_message.h
index b274194..c694e8d 100644
--- a/quiche/quic/moqt/test_tools/moqt_test_message.h
+++ b/quiche/quic/moqt/test_tools/moqt_test_message.h
@@ -32,13 +32,14 @@
  public:
   virtual ~TestMessageBase() = default;
 
-  using MessageStructuredData =
-      absl::variant<MoqtClientSetup, MoqtServerSetup, MoqtObject, MoqtSubscribe,
-                    MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe,
-                    MoqtSubscribeDone, MoqtSubscribeUpdate, MoqtAnnounce,
-                    MoqtAnnounceOk, MoqtAnnounceError, MoqtAnnounceCancel,
-                    MoqtTrackStatusRequest, MoqtUnannounce, MoqtTrackStatus,
-                    MoqtGoAway, MoqtMaxSubscribeId, MoqtObjectAck>;
+  using MessageStructuredData = absl::variant<
+      MoqtClientSetup, MoqtServerSetup, MoqtObject, MoqtSubscribe,
+      MoqtSubscribeOk, MoqtSubscribeError, MoqtUnsubscribe, MoqtSubscribeDone,
+      MoqtSubscribeUpdate, MoqtAnnounce, MoqtAnnounceOk, MoqtAnnounceError,
+      MoqtAnnounceCancel, MoqtTrackStatusRequest, MoqtUnannounce,
+      MoqtTrackStatus, MoqtGoAway, MoqtSubscribeNamespace,
+      MoqtSubscribeNamespaceOk, MoqtSubscribeNamespaceError,
+      MoqtUnsubscribeNamespace, MoqtMaxSubscribeId, MoqtObjectAck>;
 
   // The total actual size of the message.
   size_t total_message_size() const { return wire_image_size_; }
@@ -1061,6 +1062,150 @@
   };
 };
 
+class QUICHE_NO_EXPORT SubscribeNamespaceMessage : public TestMessageBase {
+ public:
+  SubscribeNamespaceMessage() : TestMessageBase() {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtSubscribeNamespace>(values);
+    if (cast.track_namespace != subscribe_namespace_.track_namespace) {
+      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE track namespace mismatch";
+      return false;
+    }
+    if (cast.parameters != subscribe_namespace_.parameters) {
+      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE parameters mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---vvv---"); }
+
+  MessageStructuredData structured_data() const override {
+    return TestMessageBase::MessageStructuredData(subscribe_namespace_);
+  }
+
+ private:
+  uint8_t raw_packet_[12] = {
+      0x11, 0x01, 0x03, 0x66, 0x6f, 0x6f,  // namespace = "foo"
+      0x01,                                // 1 parameter
+      0x02, 0x03, 0x62, 0x61, 0x72,        // authorization_info = "bar"
+  };
+
+  MoqtSubscribeNamespace subscribe_namespace_ = {
+      /*track_namespace=*/FullTrackName{"foo"},
+      /*parameters=*/
+      MoqtSubscribeParameters{"bar", std::nullopt, std::nullopt, std::nullopt},
+  };
+};
+
+class QUICHE_NO_EXPORT SubscribeNamespaceOkMessage : public TestMessageBase {
+ public:
+  SubscribeNamespaceOkMessage() : TestMessageBase() {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtSubscribeNamespaceOk>(values);
+    if (cast.track_namespace != subscribe_namespace_ok_.track_namespace) {
+      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_OK track namespace mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---"); }
+
+  MessageStructuredData structured_data() const override {
+    return TestMessageBase::MessageStructuredData(subscribe_namespace_ok_);
+  }
+
+ private:
+  uint8_t raw_packet_[6] = {
+      0x12, 0x01, 0x03, 0x66, 0x6f, 0x6f,  // namespace = "foo"
+  };
+
+  MoqtSubscribeNamespaceOk subscribe_namespace_ok_ = {
+      /*track_namespace=*/FullTrackName{"foo"},
+  };
+};
+
+class QUICHE_NO_EXPORT SubscribeNamespaceErrorMessage : public TestMessageBase {
+ public:
+  SubscribeNamespaceErrorMessage() : TestMessageBase() {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtSubscribeNamespaceError>(values);
+    if (cast.track_namespace != subscribe_namespace_error_.track_namespace) {
+      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_ERROR track namespace mismatch";
+      return false;
+    }
+    if (cast.error_code != subscribe_namespace_error_.error_code) {
+      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_ERROR error code mismatch";
+      return false;
+    }
+    if (cast.reason_phrase != subscribe_namespace_error_.reason_phrase) {
+      QUIC_LOG(INFO) << "SUBSCRIBE_NAMESPACE_ERROR reason phrase mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---vv---"); }
+
+  MessageStructuredData structured_data() const override {
+    return TestMessageBase::MessageStructuredData(subscribe_namespace_error_);
+  }
+
+ private:
+  uint8_t raw_packet_[11] = {
+      0x13, 0x01, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace = "foo"
+      0x01,                                // error_code = 1
+      0x03, 0x62, 0x61, 0x72,              // reason_phrase = "bar"
+  };
+
+  MoqtSubscribeNamespaceError subscribe_namespace_error_ = {
+      /*track_namespace=*/FullTrackName{"foo"},
+      /*error_code=*/MoqtAnnounceErrorCode::kAnnounceNotSupported,
+      /*reason_phrase=*/"bar",
+  };
+};
+
+class QUICHE_NO_EXPORT UnsubscribeNamespaceMessage : public TestMessageBase {
+ public:
+  UnsubscribeNamespaceMessage() : TestMessageBase() {
+    SetWireImage(raw_packet_, sizeof(raw_packet_));
+  }
+
+  bool EqualFieldValues(MessageStructuredData& values) const override {
+    auto cast = std::get<MoqtUnsubscribeNamespace>(values);
+    if (cast.track_namespace != unsubscribe_namespace_.track_namespace) {
+      QUIC_LOG(INFO) << "UNSUBSCRIBE_NAMESPACE track namespace mismatch";
+      return false;
+    }
+    return true;
+  }
+
+  void ExpandVarints() override { ExpandVarintsImpl("vvv---"); }
+
+  MessageStructuredData structured_data() const override {
+    return TestMessageBase::MessageStructuredData(unsubscribe_namespace_);
+  }
+
+ private:
+  uint8_t raw_packet_[6] = {
+      0x14, 0x01, 0x03, 0x66, 0x6f, 0x6f,  // track_namespace
+  };
+
+  MoqtUnsubscribeNamespace unsubscribe_namespace_ = {
+      /*track_namespace=*/FullTrackName{"foo"},
+  };
+};
+
 class QUICHE_NO_EXPORT MaxSubscribeIdMessage : public TestMessageBase {
  public:
   MaxSubscribeIdMessage() : TestMessageBase() {
@@ -1173,6 +1318,14 @@
       return std::make_unique<TrackStatusMessage>();
     case MoqtMessageType::kGoAway:
       return std::make_unique<GoAwayMessage>();
+    case MoqtMessageType::kSubscribeNamespace:
+      return std::make_unique<SubscribeNamespaceMessage>();
+    case MoqtMessageType::kSubscribeNamespaceOk:
+      return std::make_unique<SubscribeNamespaceOkMessage>();
+    case MoqtMessageType::kSubscribeNamespaceError:
+      return std::make_unique<SubscribeNamespaceErrorMessage>();
+    case MoqtMessageType::kUnsubscribeNamespace:
+      return std::make_unique<UnsubscribeNamespaceMessage>();
     case MoqtMessageType::kMaxSubscribeId:
       return std::make_unique<MaxSubscribeIdMessage>();
     case MoqtMessageType::kObjectAck: