serialization of UNSUBSCRIBE message

raven/includes/serialization/deserialization_impl.hpp

@@ -315,4 +315,15 @@ deserialize(rvn::SubscribeErrorMessage& subscribeErrorMessage, ConstSpan& span,
     return deserializedBytes;
 }
 
+template <typename ConstSpan>
+static inline deserialize_return_t
+deserialize(rvn::UnsubscribeMessage& unsubscribeMessage, ConstSpan& span, NetworkEndian = network_endian)
+{
+    std::uint64_t deserializedBytes = 0;
+
+    deserializedBytes +=
+    deserialize<ds::quic_var_int>(unsubscribeMessage.subscribeId_, span);
+
+    return deserializedBytes;
+}
 } // namespace rvn::serialization::detail

raven/includes/serialization/messages.hpp

@@ -337,9 +337,21 @@ struct SubscribeUpdateMessage
       Subscribe ID (i)
     }
 */
-struct UnsubscribeMessage
+struct UnsubscribeMessage : public ControlMessageBase<UnsubscribeMessage>
 {
-    iType subscribeId;
+    std::uint64_t subscribeId_;
+
+    UnsubscribeMessage() : ControlMessageBase(MoQtMessageType::UNSUBSCRIBE)
+    {
+    }
+
+    bool operator==(const UnsubscribeMessage& other) const = default;
+
+    friend inline std::ostream& operator<<(std::ostream& os, const UnsubscribeMessage& msg)
+    {
+        os << "SubscribeId: " << msg.subscribeId_;
+        return os;
+    }
 };
 
 /*

raven/includes/serialization/serialization_impl.hpp

@@ -1,5 +1,6 @@
 #pragma once
 
+#include "messages.hpp"
 #include <serialization/chunk.hpp>
 #include <serialization/endianness.hpp>
 #include <serialization/messages.hpp>
@@ -140,6 +141,8 @@ template <UnsignedInteger T>
  serialize_return_t serialize(ds::chunk& c, const StreamHeaderSubgroupMessage& msg);
  serialize_return_t serialize(ds::chunk& c, const StreamHeaderSubgroupObject& msg);
  serialize_return_t serialize(ds::chunk& c, const rvn::SubscribeErrorMessage& subscribeErrorMessage);
+ serialize_return_t serialize(ds::chunk& c, const rvn::UnsubscribeMessage& unsubscribeMessage);
+ serialize_return_t serialize(ds::chunk& c, const rvn::UnsubscribeMessage& unsubscribeMessage);
 ///////////////////////////////////////////////////////////////////////////////////////////////
 // clang-format on
 } // namespace rvn::serialization::detail

raven/src/serialization_impl.cpp

@@ -245,4 +245,24 @@ serialize(ds::chunk& c, const rvn::SubscribeErrorMessage& subscribeErrorMessage)
 
     return headerLen + msgLen;
 }
+
+serialize_return_t serialize(ds::chunk& c, const rvn::UnsubscribeMessage& unsubscribeMessage)
+{
+    std::uint64_t msgLen = 0;
+    // Calculate the length of the message
+    {
+        msgLen += mock_serialize<ds::quic_var_int>(unsubscribeMessage.subscribeId_);
+    }
+
+    std::uint64_t headerLen = 0;
+    // Header
+    headerLen +=
+    serialize<ds::quic_var_int>(c, utils::to_underlying(MoQtMessageType::UNSUBSCRIBE));
+    headerLen += serialize<ds::quic_var_int>(c, msgLen);
+
+    // Body
+    serialize<ds::quic_var_int>(c, unsubscribeMessage.subscribeId_);
+
+    return headerLen + msgLen;
+}
 } // namespace rvn::serialization::detail

tests/serialization/CMakeLists.txt

@@ -4,3 +4,4 @@ add_raven_test(serialize_client_setup_message.cpp)
 add_raven_test(serialize_server_setup_message.cpp)
 add_raven_test(serialize_subscribe_message.cpp)
 add_raven_test(serialize_subscribe_error.cpp)
+add_raven_test(serialize_unsubscribe_message.cpp)

tests/serialization/serialize_unsubscribe_message.cpp

@@ -0,0 +1,75 @@
+#include "test_serialization_utils.hpp"
+#include <cassert>
+#include <iostream>
+#include <serialization/chunk.hpp>
+#include <serialization/deserialization_impl.hpp>
+#include <serialization/messages.hpp>
+#include <serialization/serialization_impl.hpp>
+#include <utilities.hpp>
+
+
+using namespace rvn;
+using namespace rvn::serialization;
+
+void test_serialize_unsubscribe()
+{
+    //// Create a SubscribeErrorMessage object with sample data for a 404 error
+    UnsubscribeMessage msg;
+    ds::chunk c;
+    msg.subscribeId_ = 0x12345678;
+
+
+    serialization::detail::serialize(c, msg);
+
+    // clang-format off
+    /*
+           00001010          00000100     10010010 00110100 01010110 01111000   
+    */
+    std::string expectedSerializationString = "00001010 00100100 10010010 00110100 01010110 01111000";
+    // clang-format on
+    auto expectedSerialization = binary_string_to_vector(expectedSerializationString);
+
+    utils::ASSERT_LOG_THROW(c.size() == expectedSerialization.size(), "Size mismatch\n",
+                            "Expected size: ", expectedSerialization.size(),
+                            "\n", "Actual size: ", c.size(), "\n");
+    for (std::size_t i = 0; i < c.size(); i++)
+        utils::ASSERT_LOG_THROW(c[i] == expectedSerialization[i], "Mismatch at index: ", i,
+                                "\n", "Expected: ", int(expectedSerialization[i]),
+                                "\n", "Actual: ", int(c[i]), "\n");
+
+
+    ds::ChunkSpan span(c);
+
+    ControlMessageHeader header;
+    serialization::detail::deserialize(header, span);
+
+    utils::ASSERT_LOG_THROW(header.messageType_ == MoQtMessageType::UNSUBSCRIBE,
+                            "Message type mismatch\n", "Expected: ",
+                            utils::to_underlying(MoQtMessageType::UNSUBSCRIBE), "\n",
+                            "Actual: ", utils::to_underlying(header.messageType_), "\n");
+
+    UnsubscribeMessage deserializedMsg;
+    serialization::detail::deserialize(deserializedMsg, span);
+
+    utils::ASSERT_LOG_THROW(msg == deserializedMsg, "Deserialization failed\n",
+                            "Expected: ", msg, "\n", "Actual: ", deserializedMsg, "\n");
+}
+
+
+void tests()
+{
+    try
+    {
+        test_serialize_unsubscribe();
+    }
+    catch (const std::exception& e)
+    {
+        std::cerr << "test failed\n";
+        std::cerr << e.what() << '\n';
+    }
+}
+int main()
+{
+    tests();
+    return 0;
+}