// 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_framer.h"

#include <cstddef>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <vector>

#include "absl/strings/str_cat.h"
#include "absl/strings/string_view.h"
#include "quiche/quic/moqt/moqt_messages.h"
#include "quiche/quic/moqt/moqt_priority.h"
#include "quiche/quic/moqt/test_tools/moqt_test_message.h"
#include "quiche/quic/platform/api/quic_expect_bug.h"
#include "quiche/quic/platform/api/quic_test.h"
#include "quiche/common/quiche_buffer_allocator.h"
#include "quiche/common/simple_buffer_allocator.h"
#include "quiche/common/test_tools/quiche_test_utils.h"

namespace moqt::test {

struct MoqtFramerTestParams {
  MoqtFramerTestParams(MoqtMessageType message_type, bool uses_web_transport)
      : message_type(message_type), uses_web_transport(uses_web_transport) {}
  MoqtMessageType message_type;
  bool uses_web_transport;
};

std::vector<MoqtFramerTestParams> GetMoqtFramerTestParams() {
  std::vector<MoqtFramerTestParams> params;
  std::vector<MoqtMessageType> message_types = {
      MoqtMessageType::kSubscribe,
      MoqtMessageType::kSubscribeOk,
      MoqtMessageType::kSubscribeError,
      MoqtMessageType::kUnsubscribe,
      MoqtMessageType::kSubscribeDone,
      MoqtMessageType::kAnnounceCancel,
      MoqtMessageType::kTrackStatusRequest,
      MoqtMessageType::kTrackStatus,
      MoqtMessageType::kAnnounce,
      MoqtMessageType::kAnnounceOk,
      MoqtMessageType::kAnnounceError,
      MoqtMessageType::kUnannounce,
      MoqtMessageType::kGoAway,
      MoqtMessageType::kSubscribeAnnounces,
      MoqtMessageType::kSubscribeAnnouncesOk,
      MoqtMessageType::kSubscribeAnnouncesError,
      MoqtMessageType::kUnsubscribeAnnounces,
      MoqtMessageType::kMaxSubscribeId,
      MoqtMessageType::kFetch,
      MoqtMessageType::kFetchCancel,
      MoqtMessageType::kFetchOk,
      MoqtMessageType::kFetchError,
      MoqtMessageType::kSubscribesBlocked,
      MoqtMessageType::kObjectAck,
      MoqtMessageType::kClientSetup,
      MoqtMessageType::kServerSetup,
  };
  for (const MoqtMessageType message_type : message_types) {
    if (message_type == MoqtMessageType::kClientSetup) {
      for (const bool uses_web_transport : {false, true}) {
        params.push_back(
            MoqtFramerTestParams(message_type, uses_web_transport));
      }
    } else {
      // All other types are processed the same for either perspective or
      // transport.
      params.push_back(MoqtFramerTestParams(message_type, true));
    }
  }
  return params;
}

std::string ParamNameFormatter(
    const testing::TestParamInfo<MoqtFramerTestParams>& info) {
  return MoqtMessageTypeToString(info.param.message_type) + "_" +
         (info.param.uses_web_transport ? "WebTransport" : "QUIC");
}

quiche::QuicheBuffer SerializeObject(MoqtFramer& framer,
                                     const MoqtObject& message,
                                     absl::string_view payload,
                                     MoqtDataStreamType stream_type,
                                     bool is_first_in_stream) {
  MoqtObject adjusted_message = message;
  adjusted_message.payload_length = payload.size();
  quiche::QuicheBuffer header =
      (stream_type == MoqtDataStreamType::kObjectDatagram)
          ? framer.SerializeObjectDatagram(adjusted_message, payload)
          : framer.SerializeObjectHeader(adjusted_message, stream_type,
                                         is_first_in_stream);
  if (header.empty()) {
    return quiche::QuicheBuffer();
  }
  return quiche::QuicheBuffer::Copy(
      quiche::SimpleBufferAllocator::Get(),
      absl::StrCat(header.AsStringView(), payload));
}

class MoqtFramerTest
    : public quic::test::QuicTestWithParam<MoqtFramerTestParams> {
 public:
  MoqtFramerTest()
      : message_type_(GetParam().message_type),
        webtrans_(GetParam().uses_web_transport),
        buffer_allocator_(quiche::SimpleBufferAllocator::Get()),
        framer_(buffer_allocator_, GetParam().uses_web_transport) {}

  std::unique_ptr<TestMessageBase> MakeMessage(MoqtMessageType message_type) {
    return CreateTestMessage(message_type, webtrans_);
  }

  quiche::QuicheBuffer SerializeMessage(
      TestMessageBase::MessageStructuredData& structured_data) {
    switch (message_type_) {
      case MoqtMessageType::kSubscribe: {
        auto data = std::get<MoqtSubscribe>(structured_data);
        return framer_.SerializeSubscribe(data);
      }
      case MoqtMessageType::kSubscribeOk: {
        auto data = std::get<MoqtSubscribeOk>(structured_data);
        return framer_.SerializeSubscribeOk(data);
      }
      case MoqtMessageType::kSubscribeError: {
        auto data = std::get<MoqtSubscribeError>(structured_data);
        return framer_.SerializeSubscribeError(data);
      }
      case MoqtMessageType::kUnsubscribe: {
        auto data = std::get<MoqtUnsubscribe>(structured_data);
        return framer_.SerializeUnsubscribe(data);
      }
      case MoqtMessageType::kSubscribeDone: {
        auto data = std::get<MoqtSubscribeDone>(structured_data);
        return framer_.SerializeSubscribeDone(data);
      }
      case MoqtMessageType::kAnnounce: {
        auto data = std::get<MoqtAnnounce>(structured_data);
        return framer_.SerializeAnnounce(data);
      }
      case moqt::MoqtMessageType::kAnnounceOk: {
        auto data = std::get<MoqtAnnounceOk>(structured_data);
        return framer_.SerializeAnnounceOk(data);
      }
      case moqt::MoqtMessageType::kAnnounceError: {
        auto data = std::get<MoqtAnnounceError>(structured_data);
        return framer_.SerializeAnnounceError(data);
      }
      case moqt::MoqtMessageType::kAnnounceCancel: {
        auto data = std::get<MoqtAnnounceCancel>(structured_data);
        return framer_.SerializeAnnounceCancel(data);
      }
      case moqt::MoqtMessageType::kTrackStatusRequest: {
        auto data = std::get<MoqtTrackStatusRequest>(structured_data);
        return framer_.SerializeTrackStatusRequest(data);
      }
      case MoqtMessageType::kUnannounce: {
        auto data = std::get<MoqtUnannounce>(structured_data);
        return framer_.SerializeUnannounce(data);
      }
      case moqt::MoqtMessageType::kTrackStatus: {
        auto data = std::get<MoqtTrackStatus>(structured_data);
        return framer_.SerializeTrackStatus(data);
      }
      case moqt::MoqtMessageType::kGoAway: {
        auto data = std::get<MoqtGoAway>(structured_data);
        return framer_.SerializeGoAway(data);
      }
      case moqt::MoqtMessageType::kSubscribeAnnounces: {
        auto data = std::get<MoqtSubscribeAnnounces>(structured_data);
        return framer_.SerializeSubscribeAnnounces(data);
      }
      case moqt::MoqtMessageType::kSubscribeAnnouncesOk: {
        auto data = std::get<MoqtSubscribeAnnouncesOk>(structured_data);
        return framer_.SerializeSubscribeAnnouncesOk(data);
      }
      case moqt::MoqtMessageType::kSubscribeAnnouncesError: {
        auto data = std::get<MoqtSubscribeAnnouncesError>(structured_data);
        return framer_.SerializeSubscribeAnnouncesError(data);
      }
      case moqt::MoqtMessageType::kUnsubscribeAnnounces: {
        auto data = std::get<MoqtUnsubscribeAnnounces>(structured_data);
        return framer_.SerializeUnsubscribeAnnounces(data);
      }
      case moqt::MoqtMessageType::kMaxSubscribeId: {
        auto data = std::get<MoqtMaxSubscribeId>(structured_data);
        return framer_.SerializeMaxSubscribeId(data);
      }
      case moqt::MoqtMessageType::kFetch: {
        auto data = std::get<MoqtFetch>(structured_data);
        return framer_.SerializeFetch(data);
      }
      case moqt::MoqtMessageType::kFetchCancel: {
        auto data = std::get<MoqtFetchCancel>(structured_data);
        return framer_.SerializeFetchCancel(data);
      }
      case moqt::MoqtMessageType::kFetchOk: {
        auto data = std::get<MoqtFetchOk>(structured_data);
        return framer_.SerializeFetchOk(data);
      }
      case moqt::MoqtMessageType::kFetchError: {
        auto data = std::get<MoqtFetchError>(structured_data);
        return framer_.SerializeFetchError(data);
      }
      case moqt::MoqtMessageType::kSubscribesBlocked: {
        auto data = std::get<MoqtSubscribesBlocked>(structured_data);
        return framer_.SerializeSubscribesBlocked(data);
      }
      case moqt::MoqtMessageType::kObjectAck: {
        auto data = std::get<MoqtObjectAck>(structured_data);
        return framer_.SerializeObjectAck(data);
      }
      case MoqtMessageType::kClientSetup: {
        auto data = std::get<MoqtClientSetup>(structured_data);
        return framer_.SerializeClientSetup(data);
      }
      case MoqtMessageType::kServerSetup: {
        auto data = std::get<MoqtServerSetup>(structured_data);
        return framer_.SerializeServerSetup(data);
      }
      default:
        // kObjectDatagram is a totally different code path.
        return quiche::QuicheBuffer();
    }
  }

  MoqtMessageType message_type_;
  bool webtrans_;
  quiche::SimpleBufferAllocator* buffer_allocator_;
  MoqtFramer framer_;
};

INSTANTIATE_TEST_SUITE_P(MoqtFramerTests, MoqtFramerTest,
                         testing::ValuesIn(GetMoqtFramerTestParams()),
                         ParamNameFormatter);

TEST_P(MoqtFramerTest, OneMessage) {
  auto message = MakeMessage(message_type_);
  auto structured_data = message->structured_data();
  auto buffer = SerializeMessage(structured_data);
  EXPECT_EQ(buffer.size(), message->total_message_size());
  quiche::test::CompareCharArraysWithHexError(
      "frame encoding", buffer.data(), buffer.size(),
      message->PacketSample().data(), message->PacketSample().size());
}

class MoqtFramerSimpleTest : public quic::test::QuicTest {
 public:
  MoqtFramerSimpleTest()
      : buffer_allocator_(quiche::SimpleBufferAllocator::Get()),
        framer_(buffer_allocator_, /*web_transport=*/true) {}

  quiche::SimpleBufferAllocator* buffer_allocator_;
  MoqtFramer framer_;

  // Obtain a pointer to an arbitrary offset in a serialized buffer.
  const uint8_t* BufferAtOffset(quiche::QuicheBuffer& buffer, size_t offset) {
    const char* data = buffer.data();
    return reinterpret_cast<const uint8_t*>(data + offset);
  }
};

TEST_F(MoqtFramerSimpleTest, GroupMiddler) {
  auto header = std::make_unique<StreamHeaderSubgroupMessage>();
  auto buffer1 =
      SerializeObject(framer_, std::get<MoqtObject>(header->structured_data()),
                      "foo", MoqtDataStreamType::kStreamHeaderSubgroup, true);
  EXPECT_EQ(buffer1.size(), header->total_message_size());
  EXPECT_EQ(buffer1.AsStringView(), header->PacketSample());

  auto middler = std::make_unique<StreamMiddlerSubgroupMessage>();
  auto buffer2 =
      SerializeObject(framer_, std::get<MoqtObject>(middler->structured_data()),
                      "bar", MoqtDataStreamType::kStreamHeaderSubgroup, false);
  EXPECT_EQ(buffer2.size(), middler->total_message_size());
  EXPECT_EQ(buffer2.AsStringView(), middler->PacketSample());
}

TEST_F(MoqtFramerSimpleTest, FetchMiddler) {
  auto header = std::make_unique<StreamHeaderFetchMessage>();
  auto buffer1 =
      SerializeObject(framer_, std::get<MoqtObject>(header->structured_data()),
                      "foo", MoqtDataStreamType::kStreamHeaderFetch, true);
  EXPECT_EQ(buffer1.size(), header->total_message_size());
  EXPECT_EQ(buffer1.AsStringView(), header->PacketSample());

  auto middler = std::make_unique<StreamMiddlerFetchMessage>();
  auto buffer2 =
      SerializeObject(framer_, std::get<MoqtObject>(middler->structured_data()),
                      "bar", MoqtDataStreamType::kStreamHeaderFetch, false);
  EXPECT_EQ(buffer2.size(), middler->total_message_size());
  EXPECT_EQ(buffer2.AsStringView(), middler->PacketSample());
}

TEST_F(MoqtFramerSimpleTest, BadObjectInput) {
  MoqtObject object = {
      // This is a valid object.
      /*track_alias=*/4,
      /*group_id=*/5,
      /*object_id=*/6,
      /*publisher_priority=*/7,
      /*object_status=*/MoqtObjectStatus::kNormal,
      /*subgroup_id=*/8,
      /*payload_length=*/3,
  };
  quiche::QuicheBuffer buffer;

  // kSubgroup must have a subgroup_id.
  object.subgroup_id = std::nullopt;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectHeader(
                      object, MoqtDataStreamType::kStreamHeaderSubgroup, false),
                  "Object metadata is invalid");
  EXPECT_TRUE(buffer.empty());
  object.subgroup_id = 8;

  // kFetch must have a subgroup_id.
  object.subgroup_id = std::nullopt;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectHeader(
                      object, MoqtDataStreamType::kStreamHeaderFetch, false),
                  "Object metadata is invalid");
  EXPECT_TRUE(buffer.empty());
  object.subgroup_id = 8;

  // Non-normal status must have no payload.
  object.object_status = MoqtObjectStatus::kEndOfGroup;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectHeader(
                      object, MoqtDataStreamType::kStreamHeaderSubgroup, false),
                  "Object metadata is invalid");
  EXPECT_TRUE(buffer.empty());
  // object.object_status = MoqtObjectStatus::kNormal;
}

TEST_F(MoqtFramerSimpleTest, BadDatagramInput) {
  MoqtObject object = {
      // This is a valid datagram.
      /*track_alias=*/4,
      /*group_id=*/5,
      /*object_id=*/6,
      /*publisher_priority=*/7,
      /*object_status=*/MoqtObjectStatus::kNormal,
      /*subgroup_id=*/std::nullopt,
      /*payload_length=*/3,
  };
  quiche::QuicheBuffer buffer;

  // No datagrams to SerializeObjectHeader().
  EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectHeader(
                      object, MoqtDataStreamType::kObjectDatagram, false),
                  "Datagrams use SerializeObjectDatagram()")
  EXPECT_TRUE(buffer.empty());

  object.object_status = MoqtObjectStatus::kEndOfGroup;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectDatagram(object, "foo"),
                  "Object metadata is invalid");
  EXPECT_TRUE(buffer.empty());
  object.object_status = MoqtObjectStatus::kNormal;

  object.subgroup_id = 8;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectDatagram(object, "foo"),
                  "Object metadata is invalid");
  EXPECT_TRUE(buffer.empty());
  object.subgroup_id = std::nullopt;

  EXPECT_QUIC_BUG(buffer = framer_.SerializeObjectDatagram(object, "foobar"),
                  "Payload length does not match payload");
  EXPECT_TRUE(buffer.empty());
}

TEST_F(MoqtFramerSimpleTest, Datagram) {
  auto datagram = std::make_unique<ObjectDatagramMessage>();
  MoqtObject object = {
      /*track_alias=*/4,
      /*group_id=*/5,
      /*object_id=*/6,
      /*publisher_priority=*/7,
      /*object_status=*/MoqtObjectStatus::kNormal,
      /*subgroup_id=*/std::nullopt,
      /*payload_length=*/3,
  };
  std::string payload = "foo";
  quiche::QuicheBuffer buffer;
  buffer = framer_.SerializeObjectDatagram(object, payload);
  EXPECT_EQ(buffer.size(), datagram->total_message_size());
  EXPECT_EQ(buffer.AsStringView(), datagram->PacketSample());
}

TEST_F(MoqtFramerSimpleTest, AllSubscribeInputs) {
  for (std::optional<uint64_t> start_group :
       {std::optional<uint64_t>(), std::optional<uint64_t>(4)}) {
    for (std::optional<uint64_t> start_object :
         {std::optional<uint64_t>(), std::optional<uint64_t>(0)}) {
      for (std::optional<uint64_t> end_group :
           {std::optional<uint64_t>(), std::optional<uint64_t>(7)}) {
        for (std::optional<uint64_t> end_object :
             {std::optional<uint64_t>(), std::optional<uint64_t>(3)}) {
          MoqtSubscribe subscribe = {
              /*subscribe_id=*/3,
              /*track_alias=*/4,
              /*full_track_name=*/FullTrackName({"foo", "abcd"}),
              /*subscriber_priority=*/0x20,
              /*group_order=*/std::nullopt,
              start_group,
              start_object,
              end_group,
              end_object,
              MoqtSubscribeParameters{"bar", std::nullopt, std::nullopt,
                                      std::nullopt},
          };
          quiche::QuicheBuffer buffer;
          MoqtFilterType expected_filter_type = MoqtFilterType::kNone;
          if (!start_group.has_value() && !start_object.has_value() &&
              !end_group.has_value() && !end_object.has_value()) {
            expected_filter_type = MoqtFilterType::kLatestObject;
          } else if (!start_group.has_value() && start_object.has_value() &&
                     *start_object == 0 && !end_group.has_value() &&
                     !end_object.has_value()) {
            expected_filter_type = MoqtFilterType::kLatestGroup;
          } else if (start_group.has_value() && start_object.has_value() &&
                     !end_group.has_value() && !end_object.has_value()) {
            expected_filter_type = MoqtFilterType::kAbsoluteStart;
          } else if (start_group.has_value() && start_object.has_value() &&
                     end_group.has_value()) {
            expected_filter_type = MoqtFilterType::kAbsoluteRange;
          }
          if (expected_filter_type == MoqtFilterType::kNone) {
            EXPECT_QUIC_BUG(buffer = framer_.SerializeSubscribe(subscribe),
                            "Invalid object range");
            EXPECT_EQ(buffer.size(), 0);
            continue;
          }
          buffer = framer_.SerializeSubscribe(subscribe);
          // Go to the filter type.
          const uint8_t* read = BufferAtOffset(buffer, 16);
          EXPECT_EQ(static_cast<MoqtFilterType>(*read), expected_filter_type);
          EXPECT_GT(buffer.size(), 0);
          if (expected_filter_type == MoqtFilterType::kAbsoluteRange &&
              end_object.has_value()) {
            const uint8_t* object_id = read + 4;
            EXPECT_EQ(*object_id, *end_object + 1);
          }
        }
      }
    }
  }
}

TEST_F(MoqtFramerSimpleTest, SubscribeEndBeforeStart) {
  MoqtSubscribe subscribe = {
      /*subscribe_id=*/3,
      /*track_alias=*/4,
      /*full_track_name=*/FullTrackName({"foo", "abcd"}),
      /*subscriber_priority=*/0x20,
      /*group_order=*/std::nullopt,
      /*start_group=*/std::optional<uint64_t>(4),
      /*start_object=*/std::optional<uint64_t>(3),
      /*end_group=*/std::optional<uint64_t>(3),
      /*end_object=*/std::nullopt,
      MoqtSubscribeParameters{"bar", std::nullopt, std::nullopt, std::nullopt},
  };
  quiche::QuicheBuffer buffer;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeSubscribe(subscribe),
                  "Invalid object range");
  EXPECT_EQ(buffer.size(), 0);
  subscribe.end_group = 4;
  subscribe.end_object = 1;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeSubscribe(subscribe),
                  "Invalid object range");
  EXPECT_EQ(buffer.size(), 0);
}

TEST_F(MoqtFramerSimpleTest, FetchEndBeforeStart) {
  MoqtFetch fetch = {
      /*subscribe_id =*/1,
      /*full_track_name=*/FullTrackName{"foo", "bar"},
      /*subscriber_priority=*/2,
      /*group_order=*/MoqtDeliveryOrder::kAscending,
      /*start_object=*/FullSequence{1, 2},
      /*end_group=*/1,
      /*end_object=*/1,
      /*parameters=*/
      MoqtSubscribeParameters{"baz", std::nullopt, std::nullopt, std::nullopt},
  };
  quiche::QuicheBuffer buffer;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeFetch(fetch),
                  "Invalid FETCH object range");
  EXPECT_EQ(buffer.size(), 0);
  fetch.end_group = 0;
  fetch.end_object = std::nullopt;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeFetch(fetch),
                  "Invalid FETCH object range");
  EXPECT_EQ(buffer.size(), 0);
}

TEST_F(MoqtFramerSimpleTest, SubscribeLatestGroupNonzeroObject) {
  MoqtSubscribe subscribe = {
      /*subscribe_id=*/3,
      /*track_alias=*/4,
      /*full_track_name=*/FullTrackName({"foo", "abcd"}),
      /*subscriber_priority=*/0x20,
      /*group_order=*/std::nullopt,
      /*start_group=*/std::nullopt,
      /*start_object=*/std::optional<uint64_t>(3),
      /*end_group=*/std::nullopt,
      /*end_object=*/std::nullopt,
      MoqtSubscribeParameters{"bar", std::nullopt, std::nullopt, std::nullopt},
  };
  quiche::QuicheBuffer buffer;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeSubscribe(subscribe),
                  "Invalid object range");
  EXPECT_EQ(buffer.size(), 0);
}

TEST_F(MoqtFramerSimpleTest, SubscribeUpdateEndGroupOnly) {
  MoqtSubscribeUpdate subscribe_update = {
      /*subscribe_id=*/3,
      /*start_group=*/4,
      /*start_object=*/3,
      /*end_group=*/4,
      /*end_object=*/std::nullopt,
      /*subscriber_priority=*/0xaa,
      MoqtSubscribeParameters{std::nullopt, std::nullopt, std::nullopt,
                              std::nullopt},
  };
  quiche::QuicheBuffer buffer;
  buffer = framer_.SerializeSubscribeUpdate(subscribe_update);
  EXPECT_GT(buffer.size(), 0);
  const uint8_t* end_group = BufferAtOffset(buffer, 5);
  EXPECT_EQ(*end_group, 5);
  const uint8_t* end_object = end_group + 1;
  EXPECT_EQ(*end_object, 0);
}

TEST_F(MoqtFramerSimpleTest, SubscribeUpdateIncrementsEnd) {
  MoqtSubscribeUpdate subscribe_update = {
      /*subscribe_id=*/3,
      /*start_group=*/4,
      /*start_object=*/3,
      /*end_group=*/4,
      /*end_object=*/6,
      /*subscriber_priority=*/0xaa,
      MoqtSubscribeParameters{std::nullopt, std::nullopt, std::nullopt,
                              std::nullopt},
  };
  quiche::QuicheBuffer buffer;
  buffer = framer_.SerializeSubscribeUpdate(subscribe_update);
  EXPECT_GT(buffer.size(), 0);
  const uint8_t* end_group = BufferAtOffset(buffer, 5);
  EXPECT_EQ(*end_group, 5);
  const uint8_t* end_object = end_group + 1;
  EXPECT_EQ(*end_object, 7);
}

TEST_F(MoqtFramerSimpleTest, SubscribeUpdateInvalidRange) {
  MoqtSubscribeUpdate subscribe_update = {
      /*subscribe_id=*/3,
      /*start_group=*/4,
      /*start_object=*/3,
      /*end_group=*/std::nullopt,
      /*end_object=*/6,
      /*subscriber_priority=*/0xaa,
      MoqtSubscribeParameters{std::nullopt, std::nullopt, std::nullopt,
                              std::nullopt},
  };
  quiche::QuicheBuffer buffer;
  EXPECT_QUIC_BUG(buffer = framer_.SerializeSubscribeUpdate(subscribe_update),
                  "Invalid object range");
  EXPECT_EQ(buffer.size(), 0);
}

}  // namespace moqt::test