mediasoup 3.19.21 → 3.20.0

package/worker/test/src/RTC/SCTP/tx/TestRoundRobinSendQueue.cpp

@@ -0,0 +1,1130 @@
+#include "common.hpp"
+#include "RTC/SCTP/public/Message.hpp"
+#include "RTC/SCTP/public/SctpOptions.hpp"
+#include "RTC/SCTP/tx/RoundRobinSendQueue.hpp"
+#include "mocks/include/RTC/SCTP/association/MockAssociationListener.hpp"
+#include <catch2/catch_test_macros.hpp>
+#include <ranges>
+#include <vector>
+
+SCENARIO("SCTP RoundRobinSendQueue", "[sctp][roundrobinsendqueue]")
+{
+	constexpr size_t Mtu{ 1100 };
+	constexpr uint64_t NowMs{ 0 };
+	constexpr uint16_t StreamId{ 1 };
+	constexpr uint32_t Ppid{ 53 };
+	constexpr uint16_t DefaultPriority{ 10 };
+	constexpr size_t BufferedAmountLowThreshold{ 500 };
+	constexpr size_t OneFragmentPacketLength{ 100 };
+	constexpr size_t TwoFragmentPacketLength{ 101 };
+
+	SECTION("empty buffer")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		REQUIRE(q.IsEmpty());
+		REQUIRE(q.Produce(NowMs, OneFragmentPacketLength).has_value() == false);
+	}
+
+	SECTION("add and get single chunk")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, { 1, 2, 4, 5, 6 }));
+
+		REQUIRE(!q.IsEmpty());
+
+		const auto dataToSend = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSend.has_value());
+		REQUIRE(dataToSend->data.IsBeginning());
+		REQUIRE(dataToSend->data.IsEnd());
+	}
+
+	SECTION("carve out beginning middle and end")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(60);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		const auto dataToSendBeg = q.Produce(NowMs, /*maxLength*/ 20);
+
+		REQUIRE(dataToSendBeg.has_value());
+		REQUIRE(dataToSendBeg->data.IsBeginning());
+		REQUIRE(!dataToSendBeg->data.IsEnd());
+
+		const auto dataToSendMid = q.Produce(NowMs, /*maxLength*/ 20);
+
+		REQUIRE(dataToSendMid.has_value());
+		REQUIRE(!dataToSendMid->data.IsBeginning());
+		REQUIRE(!dataToSendMid->data.IsEnd());
+
+		const auto dataToSendEnd = q.Produce(NowMs, /*maxLength*/ 20);
+
+		REQUIRE(dataToSendEnd.has_value());
+		REQUIRE(!dataToSendEnd->data.IsBeginning());
+		REQUIRE(dataToSendEnd->data.IsEnd());
+
+		REQUIRE(q.Produce(NowMs, OneFragmentPacketLength).has_value() == false);
+	}
+
+	SECTION("get chunks from two messages")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(60);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+		q.AddMessage(NowMs, RTC::SCTP::Message(3, 54, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == StreamId);
+		REQUIRE(dataToSendOne->data.GetPayloadProtocolId() == Ppid);
+		REQUIRE(dataToSendOne->data.IsBeginning());
+		REQUIRE(dataToSendOne->data.IsEnd());
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == 3);
+		REQUIRE(dataToSendTwo->data.GetPayloadProtocolId() == 54);
+		REQUIRE(dataToSendTwo->data.IsBeginning());
+		REQUIRE(dataToSendTwo->data.IsEnd());
+	}
+
+	SECTION("buffer becomes full and emptied")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(600);
+
+		REQUIRE(q.GetTotalBufferedAmount() < 1000);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		REQUIRE(q.GetTotalBufferedAmount() < 1000);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(3, 54, payload));
+
+		REQUIRE(q.GetTotalBufferedAmount() >= 1000);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(5, 55, payload));
+
+		REQUIRE(q.GetTotalBufferedAmount() >= 1000);
+
+		auto dataToSendOne = q.Produce(NowMs, 1000);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == StreamId);
+		REQUIRE(dataToSendOne->data.GetPayloadProtocolId() == Ppid);
+
+		REQUIRE(q.GetTotalBufferedAmount() >= 1000);
+
+		auto dataToSendTwo = q.Produce(NowMs, 1000);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == 3);
+		REQUIRE(dataToSendTwo->data.GetPayloadProtocolId() == 54);
+
+		REQUIRE(q.GetTotalBufferedAmount() < 1000);
+		REQUIRE(!q.IsEmpty());
+
+		auto dataToSendThree = q.Produce(NowMs, 1000);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.GetStreamId() == 5);
+		REQUIRE(dataToSendThree->data.GetPayloadProtocolId() == 55);
+
+		REQUIRE(q.GetTotalBufferedAmount() < 1000);
+		REQUIRE(q.IsEmpty());
+	}
+
+	SECTION("defaults to ordered send")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(20);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(!dataToSendOne->data.IsUnordered());
+
+		RTC::SCTP::SendMessageOptions options;
+
+		options.unordered = true;
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload), options);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.IsUnordered());
+	}
+
+	SECTION("produce with lifetime expiry")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(20);
+
+		uint64_t now = NowMs;
+
+		q.AddMessage(now, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		now += 1000000;
+
+		REQUIRE(q.Produce(now, OneFragmentPacketLength).has_value());
+
+		RTC::SCTP::SendMessageOptions expires2s;
+
+		expires2s.lifetimeMs = 2000;
+
+		q.AddMessage(now, RTC::SCTP::Message(StreamId, Ppid, payload), expires2s);
+
+		now += 2000;
+
+		REQUIRE(q.Produce(now, OneFragmentPacketLength).has_value());
+
+		q.AddMessage(now, RTC::SCTP::Message(StreamId, Ppid, payload), expires2s);
+
+		now += 2001;
+
+		REQUIRE(!q.Produce(now, OneFragmentPacketLength).has_value());
+
+		q.AddMessage(now, RTC::SCTP::Message(StreamId, Ppid, payload), expires2s);
+
+		now += 1000000;
+
+		REQUIRE(!q.Produce(now, OneFragmentPacketLength).has_value());
+
+		RTC::SCTP::SendMessageOptions expires4s;
+
+		expires4s.lifetimeMs = 4000;
+
+		q.AddMessage(now, RTC::SCTP::Message(StreamId, Ppid, payload), expires2s);
+		q.AddMessage(now, RTC::SCTP::Message(StreamId, Ppid, payload), expires4s);
+
+		now += 2001;
+
+		REQUIRE(q.Produce(now, OneFragmentPacketLength).has_value());
+		REQUIRE(!q.Produce(now, OneFragmentPacketLength).has_value());
+	}
+
+	SECTION("discard partial packets")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(120);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+		q.AddMessage(NowMs, RTC::SCTP::Message(2, 54, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(!dataToSendOne->data.IsEnd());
+		REQUIRE(dataToSendOne->data.GetStreamId() == StreamId);
+
+		q.Discard(dataToSendOne->data.GetStreamId(), dataToSendOne->outgoingMessageId);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(!dataToSendTwo->data.IsEnd());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == 2);
+
+		const auto dataToSendThree = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.IsEnd());
+		REQUIRE(dataToSendThree->data.GetStreamId() == 2);
+
+		REQUIRE(!q.Produce(NowMs, OneFragmentPacketLength).has_value());
+
+		q.Discard(dataToSendOne->data.GetStreamId(), dataToSendOne->outgoingMessageId);
+
+		REQUIRE(!q.Produce(NowMs, OneFragmentPacketLength).has_value());
+	}
+
+	SECTION("prepare reset streams discards stream")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, { 1, 2, 3 }));
+		q.AddMessage(NowMs, RTC::SCTP::Message(2, 54, { 1, 2, 3, 4, 5 }));
+
+		REQUIRE(q.GetTotalBufferedAmount() == 8);
+
+		q.PrepareResetStream(StreamId);
+
+		REQUIRE(q.GetTotalBufferedAmount() == 5);
+
+		const auto streamsReadyToBeReset = q.GetStreamsReadyToBeReset();
+
+		REQUIRE(streamsReadyToBeReset.size() == 1);
+
+		REQUIRE(std::ranges::find(streamsReadyToBeReset, StreamId) != streamsReadyToBeReset.end());
+
+		q.CommitResetStreams();
+		q.PrepareResetStream(2);
+
+		REQUIRE(q.GetTotalBufferedAmount() == 0);
+	}
+
+	SECTION("prepare reset streams not partial packets")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(120);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, 50);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == StreamId);
+
+		REQUIRE(q.GetTotalBufferedAmount() == (2 * payload.size()) - 50);
+
+		q.PrepareResetStream(StreamId);
+
+		REQUIRE(q.GetTotalBufferedAmount() == payload.size() - 50);
+	}
+
+	SECTION("enqueued items are paused during stream reset")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(50);
+
+		q.PrepareResetStream(StreamId);
+
+		REQUIRE(q.GetTotalBufferedAmount() == 0);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		REQUIRE(q.GetTotalBufferedAmount() == payload.size());
+
+		REQUIRE(!q.Produce(NowMs, OneFragmentPacketLength).has_value());
+
+		REQUIRE(q.HasStreamsReadyToBeReset());
+
+		const auto streamsReadyToBeReset = q.GetStreamsReadyToBeReset();
+
+		REQUIRE(streamsReadyToBeReset.size() == 1);
+		REQUIRE(std::ranges::find(streamsReadyToBeReset, StreamId) != streamsReadyToBeReset.end());
+
+		REQUIRE(!q.Produce(NowMs, OneFragmentPacketLength).has_value());
+
+		q.CommitResetStreams();
+
+		REQUIRE(q.GetTotalBufferedAmount() == payload.size());
+
+		const auto dataToSendOne = q.Produce(NowMs, 50);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == StreamId);
+
+		REQUIRE(q.GetTotalBufferedAmount() == 0);
+	}
+
+	SECTION("paused streams still send partial messages until end")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const size_t payloadLength  = 100;
+		const size_t fragmentLength = 50;
+
+		const std::vector<uint8_t> payload(payloadLength);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, fragmentLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == StreamId);
+
+		REQUIRE(q.GetTotalBufferedAmount() == (2 * payloadLength) - fragmentLength);
+
+		q.PrepareResetStream(StreamId);
+
+		REQUIRE(q.GetTotalBufferedAmount() == payloadLength - fragmentLength);
+
+		const auto dataToSendTwo = q.Produce(NowMs, fragmentLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == StreamId);
+
+		REQUIRE(q.GetTotalBufferedAmount() == 0);
+
+		REQUIRE(!q.Produce(NowMs, fragmentLength).has_value());
+	}
+
+	SECTION("committing resets SSN")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(50);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamSequenceNumber() == 0);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamSequenceNumber() == 1);
+
+		q.PrepareResetStream(StreamId);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		REQUIRE(q.HasStreamsReadyToBeReset());
+
+		const auto streamsReadyToBeReset = q.GetStreamsReadyToBeReset();
+
+		REQUIRE(streamsReadyToBeReset.size() == 1);
+		REQUIRE(std::ranges::find(streamsReadyToBeReset, StreamId) != streamsReadyToBeReset.end());
+
+		q.CommitResetStreams();
+
+		const auto dataToSendThree = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.GetStreamSequenceNumber() == 0);
+	}
+
+	SECTION("committing does not reset message id")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(50);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamSequenceNumber() == 0);
+		REQUIRE(dataToSendOne->outgoingMessageId == 0);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamSequenceNumber() == 1);
+		REQUIRE(dataToSendTwo->outgoingMessageId == 1);
+
+		q.PrepareResetStream(StreamId);
+
+		const auto streamsReadyToBeReset = q.GetStreamsReadyToBeReset();
+
+		REQUIRE(streamsReadyToBeReset.size() == 1);
+		REQUIRE(std::ranges::find(streamsReadyToBeReset, StreamId) != streamsReadyToBeReset.end());
+
+		q.CommitResetStreams();
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		const auto dataToSendThree = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.GetStreamSequenceNumber() == 0);
+		REQUIRE(dataToSendThree->outgoingMessageId == 2);
+	}
+
+	SECTION("committing resets SSN for paused streams only")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(50);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, payload));
+		q.AddMessage(NowMs, RTC::SCTP::Message(3, Ppid, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+		REQUIRE(dataToSendOne->data.GetStreamSequenceNumber() == 0);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == 3);
+		REQUIRE(dataToSendTwo->data.GetStreamSequenceNumber() == 0);
+
+		q.PrepareResetStream(3);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, payload));
+		q.AddMessage(NowMs, RTC::SCTP::Message(3, Ppid, payload));
+
+		const auto streamsReadyToBeReset = q.GetStreamsReadyToBeReset();
+
+		REQUIRE(streamsReadyToBeReset.size() == 1);
+		REQUIRE(std::ranges::find(streamsReadyToBeReset, 3) != streamsReadyToBeReset.end());
+
+		q.CommitResetStreams();
+
+		const auto dataToSendThree = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.GetStreamId() == 1);
+		REQUIRE(dataToSendThree->data.GetStreamSequenceNumber() == 1);
+
+		const auto dataToSendFour = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendFour.has_value());
+		REQUIRE(dataToSendFour->data.GetStreamId() == 3);
+		REQUIRE(dataToSendFour->data.GetStreamSequenceNumber() == 0);
+	}
+
+	SECTION("rollback resumes SSN")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(50);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamSequenceNumber() == 0);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamSequenceNumber() == 1);
+
+		q.PrepareResetStream(1);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		const auto streamsReadyToBeReset = q.GetStreamsReadyToBeReset();
+
+		REQUIRE(streamsReadyToBeReset.size() == 1);
+		REQUIRE(std::ranges::find(streamsReadyToBeReset, 1) != streamsReadyToBeReset.end());
+
+		q.RollbackResetStreams();
+
+		const auto dataToSendThree = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.GetStreamSequenceNumber() == 2);
+	}
+
+	SECTION("returns fragments for one message before moving to next")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(200);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, payload));
+		q.AddMessage(NowMs, RTC::SCTP::Message(2, Ppid, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == 1);
+
+		const auto dataToSendThree = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.GetStreamId() == 2);
+
+		const auto dataToSendFour = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendFour.has_value());
+		REQUIRE(dataToSendFour->data.GetStreamId() == 2);
+	}
+
+	SECTION("returns also small fragments before moving to next")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(TwoFragmentPacketLength);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, payload));
+		q.AddMessage(NowMs, RTC::SCTP::Message(2, Ppid, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+		REQUIRE(dataToSendOne->data.GetPayloadLength() == OneFragmentPacketLength);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == 1);
+		REQUIRE(
+		  dataToSendTwo->data.GetPayloadLength() == TwoFragmentPacketLength - OneFragmentPacketLength);
+
+		const auto dataToSendThree = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.GetStreamId() == 2);
+		REQUIRE(dataToSendThree->data.GetPayloadLength() == OneFragmentPacketLength);
+
+		const auto dataToSendFour = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendFour.has_value());
+		REQUIRE(dataToSendFour->data.GetStreamId() == 2);
+		REQUIRE(
+		  dataToSendFour->data.GetPayloadLength() == TwoFragmentPacketLength - OneFragmentPacketLength);
+	}
+
+	SECTION("will cycle in round robin fashion between streams")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(1)));
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(2)));
+		q.AddMessage(NowMs, RTC::SCTP::Message(2, Ppid, std::vector<uint8_t>(3)));
+		q.AddMessage(NowMs, RTC::SCTP::Message(2, Ppid, std::vector<uint8_t>(4)));
+		q.AddMessage(NowMs, RTC::SCTP::Message(3, Ppid, std::vector<uint8_t>(5)));
+		q.AddMessage(NowMs, RTC::SCTP::Message(3, Ppid, std::vector<uint8_t>(6)));
+		q.AddMessage(NowMs, RTC::SCTP::Message(4, Ppid, std::vector<uint8_t>(7)));
+		q.AddMessage(NowMs, RTC::SCTP::Message(4, Ppid, std::vector<uint8_t>(8)));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+		REQUIRE(dataToSendOne->data.GetPayloadLength() == 1);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == 2);
+		REQUIRE(dataToSendTwo->data.GetPayloadLength() == 3);
+
+		const auto dataToSendThree = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.GetStreamId() == 3);
+		REQUIRE(dataToSendThree->data.GetPayloadLength() == 5);
+
+		const auto dataToSendFour = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendFour.has_value());
+		REQUIRE(dataToSendFour->data.GetStreamId() == 4);
+		REQUIRE(dataToSendFour->data.GetPayloadLength() == 7);
+
+		const auto dataToSendFive = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendFive.has_value());
+		REQUIRE(dataToSendFive->data.GetStreamId() == 1);
+		REQUIRE(dataToSendFive->data.GetPayloadLength() == 2);
+
+		const auto dataToSendSix = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendSix.has_value());
+		REQUIRE(dataToSendSix->data.GetStreamId() == 2);
+		REQUIRE(dataToSendSix->data.GetPayloadLength() == 4);
+
+		const auto dataToSendSeven = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendSeven.has_value());
+		REQUIRE(dataToSendSeven->data.GetStreamId() == 3);
+		REQUIRE(dataToSendSeven->data.GetPayloadLength() == 6);
+
+		const auto dataToSendEight = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendEight.has_value());
+		REQUIRE(dataToSendEight->data.GetStreamId() == 4);
+		REQUIRE(dataToSendEight->data.GetPayloadLength() == 8);
+	}
+
+	SECTION("doesn't trigger stream buffered amount low when set to zero")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.SetStreamBufferedAmountLowThreshold(1, 0);
+
+		REQUIRE(!associationListener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(1));
+	}
+
+	SECTION("triggers stream buffered amount low when sent")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(1)));
+
+		REQUIRE(q.GetStreamBufferedAmount(1) == 1);
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(associationListener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(1));
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(1) == 1);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+		REQUIRE(dataToSendOne->data.GetPayloadLength() == 1);
+		REQUIRE(q.GetStreamBufferedAmount(1) == 0);
+	}
+
+	SECTION("will retrigger stream buffered amount low if adding more")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(1)));
+
+		REQUIRE(q.GetStreamBufferedAmount(1) == 1);
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(associationListener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(1));
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(1) == 1);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(1)));
+
+		REQUIRE(q.GetStreamBufferedAmount(1) == 1);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(associationListener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(1));
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(1) == 2);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+		REQUIRE(dataToSendOne->data.GetPayloadLength() == 1);
+		REQUIRE(q.GetStreamBufferedAmount(1) == 0);
+	}
+
+	SECTION("only triggers stream buffered amount low when transitioning from above to below or equal")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.SetStreamBufferedAmountLowThreshold(1, 1000);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(10)));
+
+		REQUIRE(q.GetStreamBufferedAmount(1) == 10);
+
+		// Shouldn't trigger the event.
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(!associationListener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(1));
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+		REQUIRE(dataToSendOne->data.GetPayloadLength() == 10);
+		REQUIRE(q.GetStreamBufferedAmount(1) == 0);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(20)));
+
+		REQUIRE(q.GetStreamBufferedAmount(1) == 20);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(!associationListener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(1));
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == 1);
+		REQUIRE(dataToSendTwo->data.GetPayloadLength() == 20);
+		REQUIRE(q.GetStreamBufferedAmount(1) == 0);
+	}
+
+	SECTION("will trigger stream buffered amount low set above zero")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.SetStreamBufferedAmountLowThreshold(1, 700);
+
+		const std::vector<uint8_t> payload(1000);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, payload));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+		REQUIRE(dataToSendOne->data.GetPayloadLength() == OneFragmentPacketLength);
+		REQUIRE(q.GetStreamBufferedAmount(1) == 900);
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetPayloadLength() == OneFragmentPacketLength);
+		REQUIRE(q.GetStreamBufferedAmount(1) == 800);
+
+		// It goes beyond 700 bytes, it should trigger the event.
+		const auto dataToSendThree = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(associationListener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(1));
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(1) == 1);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.GetPayloadLength() == OneFragmentPacketLength);
+		REQUIRE(q.GetStreamBufferedAmount(1) == 700);
+
+		// Buffer decreases so it shouldn't emit the event.
+		const auto dataToSendFour = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(1) == 1);
+
+		REQUIRE(dataToSendFour.has_value());
+		REQUIRE(dataToSendFour->data.GetPayloadLength() == OneFragmentPacketLength);
+		REQUIRE(q.GetStreamBufferedAmount(1) == 600);
+	}
+
+	SECTION("will retrigger stream buffered amount low set above zero")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.SetStreamBufferedAmountLowThreshold(1, 700);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(1000)));
+
+		const auto dataToSendOne = q.Produce(NowMs, 400);
+
+		REQUIRE(associationListener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(1));
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(1) == 1);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+		REQUIRE(dataToSendOne->data.GetPayloadLength() == 400);
+		REQUIRE(q.GetStreamBufferedAmount(1) == 600);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(200)));
+
+		REQUIRE(q.GetStreamBufferedAmount(1) == 800);
+
+		const auto dataToSendTwo = q.Produce(NowMs, 200);
+
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(1) == 2);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == 1);
+		REQUIRE(dataToSendTwo->data.GetPayloadLength() == 200);
+		REQUIRE(q.GetStreamBufferedAmount(1) == 600);
+	}
+
+	SECTION("triggers stream buffered amount low on threshold changed")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, std::vector<uint8_t>(100)));
+
+		// Modifying the threshold, still under buffered_amount, should not trigger
+		// event.
+		q.SetStreamBufferedAmountLowThreshold(StreamId, 50);
+		q.SetStreamBufferedAmountLowThreshold(StreamId, 99);
+
+		REQUIRE(!associationListener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(StreamId));
+
+		// When the threshold reaches buffered_amount, it will trigger event.
+		q.SetStreamBufferedAmountLowThreshold(StreamId, 100);
+
+		REQUIRE(associationListener.HasOnStreamBufferedAmountLowBeenCalledWithStreamId(StreamId));
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(StreamId) == 1);
+
+		// But not when it's set low again.
+		q.SetStreamBufferedAmountLowThreshold(StreamId, 50);
+
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(StreamId) == 1);
+
+		// But it will trigger when it overshoots.
+		q.SetStreamBufferedAmountLowThreshold(StreamId, 150);
+
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(StreamId) == 2);
+
+		// But not when it's set back to zero.
+		q.SetStreamBufferedAmountLowThreshold(StreamId, 0);
+
+		REQUIRE(associationListener.CountOnStreamBufferedAmountLowCallsWithStreamId(StreamId) == 2);
+	}
+
+	SECTION("total buffered amount low does not trigger on buffer filling up")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(BufferedAmountLowThreshold - 1);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		REQUIRE(q.GetTotalBufferedAmount() == payload.size());
+
+		// Will not trigger if going above but never below.
+		q.AddMessage(
+		  NowMs, RTC::SCTP::Message(StreamId, Ppid, std::vector<uint8_t>(OneFragmentPacketLength)));
+
+		REQUIRE(associationListener.CountOnTotalBufferedAmountLowCalls() == 0);
+		REQUIRE(q.GetTotalBufferedAmount() > payload.size());
+	}
+
+	SECTION("triggers total buffered amount low when crossing")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(BufferedAmountLowThreshold);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, payload));
+
+		REQUIRE(q.GetTotalBufferedAmount() == payload.size());
+
+		// Reaches it.
+		q.AddMessage(NowMs, RTC::SCTP::Message(StreamId, Ppid, std::vector<uint8_t>(1)));
+
+		// Drain it a bit, will trigger.
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(associationListener.CountOnTotalBufferedAmountLowCalls() == 1);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(q.GetTotalBufferedAmount() < BufferedAmountLowThreshold);
+	}
+
+	SECTION("will stay in a stream as long as that message is sending")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		constexpr size_t OneFragmentPacketSize = OneFragmentPacketLength;
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(5, Ppid, std::vector<uint8_t>(1)));
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketSize);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 5);
+		REQUIRE(dataToSendOne->data.GetPayloadLength() == 1);
+
+		// Next, it should pick a different stream.
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(OneFragmentPacketSize * 2)));
+
+		const auto dataToSendTwo = q.Produce(NowMs, OneFragmentPacketSize);
+
+		REQUIRE(dataToSendTwo.has_value());
+		REQUIRE(dataToSendTwo->data.GetStreamId() == 1);
+		REQUIRE(dataToSendTwo->data.GetPayloadLength() == OneFragmentPacketSize);
+
+		// It should still stay on the Stream1 now, even if might be tempted to switch
+		// to this stream, as it's the stream following 5.
+		q.AddMessage(NowMs, RTC::SCTP::Message(6, Ppid, std::vector<uint8_t>(1)));
+
+		const auto dataToSendThree = q.Produce(NowMs, OneFragmentPacketSize);
+
+		REQUIRE(dataToSendThree.has_value());
+		REQUIRE(dataToSendThree->data.GetStreamId() == 1);
+		REQUIRE(dataToSendThree->data.GetPayloadLength() == OneFragmentPacketSize);
+
+		// After stream 1 message is complete, it should move to stream 6.
+		const auto dataToSendFour = q.Produce(NowMs, OneFragmentPacketSize);
+
+		REQUIRE(dataToSendFour.has_value());
+		REQUIRE(dataToSendFour->data.GetStreamId() == 6);
+		REQUIRE(dataToSendFour->data.GetPayloadLength() == 1);
+
+		REQUIRE(q.Produce(NowMs, OneFragmentPacketSize).has_value() == false);
+	}
+
+	SECTION("streams have initial priority")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		REQUIRE(q.GetStreamPriority(1) == DefaultPriority);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(2, Ppid, std::vector<uint8_t>(40)));
+
+		REQUIRE(q.GetStreamPriority(2) == DefaultPriority);
+	}
+
+	SECTION("can change stream priority")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.SetStreamPriority(1, 42);
+
+		REQUIRE(q.GetStreamPriority(1) == 42);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(2, Ppid, std::vector<uint8_t>(40)));
+		q.SetStreamPriority(2, 42);
+
+		REQUIRE(q.GetStreamPriority(2) == 42);
+	}
+
+	SECTION("will send messages by priority")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		q.EnableMessageInterleaving(true);
+
+		q.SetStreamPriority(1, 10);
+		q.SetStreamPriority(2, 20);
+		q.SetStreamPriority(3, 30);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, std::vector<uint8_t>(40)));
+		q.AddMessage(NowMs, RTC::SCTP::Message(2, Ppid, std::vector<uint8_t>(20)));
+		q.AddMessage(NowMs, RTC::SCTP::Message(3, Ppid, std::vector<uint8_t>(10)));
+
+		const std::vector<uint16_t> expectedStreams = { 3, 2, 2, 1, 1, 1, 1 };
+
+		for (const uint16_t streamId : expectedStreams)
+		{
+			const auto dataToSend = q.Produce(NowMs, 10);
+
+			REQUIRE(dataToSend.has_value());
+			REQUIRE(dataToSend->data.GetStreamId() == streamId);
+		}
+
+		REQUIRE(q.Produce(NowMs, 1).has_value() == false);
+	}
+
+	SECTION("will send lifecycle expire when expired in send queue")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(OneFragmentPacketLength);
+
+		RTC::SCTP::SendMessageOptions options;
+
+		options.lifetimeMs  = 1000;
+		options.lifecycleId = 1;
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(2, Ppid, payload), options);
+
+		REQUIRE(q.Produce(NowMs + 1001, OneFragmentPacketLength).has_value() == false);
+
+		REQUIRE(associationListener.HasOnAssociationLifecycleMessageExpiredSentBeenCalledWithLifecycleId(
+		  1, false));
+		REQUIRE(associationListener.HasOnAssociationLifecycleMessageEndBeenCalledWithLifecycleId(1));
+	}
+
+	SECTION("will send lifecycle expire when discarding during pause")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(120);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, payload), { .lifecycleId = 1 });
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, payload), { .lifecycleId = 2 });
+
+		const auto dataToSendOne = q.Produce(NowMs, 50);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+
+		REQUIRE(q.GetTotalBufferedAmount() == (2 * payload.size()) - 50);
+
+		q.PrepareResetStream(1);
+
+		REQUIRE(associationListener.HasOnAssociationLifecycleMessageExpiredSentBeenCalledWithLifecycleId(
+		  2, false));
+		REQUIRE(associationListener.HasOnAssociationLifecycleMessageEndBeenCalledWithLifecycleId(2));
+
+		REQUIRE(q.GetTotalBufferedAmount() == payload.size() - 50);
+	}
+
+	SECTION("will send lifecycle expire when discarding explicitly")
+	{
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		RTC::SCTP::RoundRobinSendQueue q(
+		  associationListener, Mtu, DefaultPriority, BufferedAmountLowThreshold);
+
+		const std::vector<uint8_t> payload(OneFragmentPacketLength + 20);
+
+		q.AddMessage(NowMs, RTC::SCTP::Message(1, Ppid, payload), { .lifecycleId = 1 });
+
+		const auto dataToSendOne = q.Produce(NowMs, OneFragmentPacketLength);
+
+		REQUIRE(dataToSendOne.has_value());
+		REQUIRE(!dataToSendOne->data.IsEnd());
+		REQUIRE(dataToSendOne->data.GetStreamId() == 1);
+
+		q.Discard(dataToSendOne->data.GetStreamId(), dataToSendOne->outgoingMessageId);
+
+		REQUIRE(associationListener.HasOnAssociationLifecycleMessageExpiredSentBeenCalledWithLifecycleId(
+		  1, false));
+		REQUIRE(associationListener.HasOnAssociationLifecycleMessageEndBeenCalledWithLifecycleId(1));
+	}
+}