mediasoup 3.19.21 → 3.20.0

package/worker/test/src/RTC/RTP/TestRtpStreamRecv.cpp

@@ -1,8 +1,8 @@
 #include "common.hpp"
-#include "DepLibUV.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/RtpStream.hpp"
 #include "RTC/RTP/RtpStreamRecv.hpp"
+#include "mocks/include/MockShared.hpp"
 #include <catch2/catch_test_macros.hpp>
 #include <vector>
 
@@ -118,8 +118,14 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 		std::vector<uint16_t> nackedSeqNumbers;
 	};
 
+	mocks::MockShared shared(/*getTimeMs*/
+	                         []()
+	                         {
+		                         return 1000;
+	                         });
+
 	// clang-format off
-	uint8_t buffer[] =
+	alignas(4) uint8_t buffer[] =
 	{
 		0x80, 0x01, 0x00, 0x01,
 		0x00, 0x00, 0x00, 0x04,
@@ -148,7 +154,8 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 	SECTION("NACK one packet")
 	{
 		RtpStreamRecvListener listener;
-		RTC::RTP::RtpStreamRecv rtpStream(&listener, params, SendNackDelay, UseRtpInactivityCheck);
+		RTC::RTP::RtpStreamRecv rtpStream(
+		  std::addressof(listener), std::addressof(shared), params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(1);
 		rtpStream.ReceivePacket(packet.get());
@@ -177,7 +184,8 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 	SECTION("receive RTX before corresponding RTP")
 	{
 		RtpStreamRecvListener listener;
-		RTC::RTP::RtpStreamRecv rtpStream(&listener, params, SendNackDelay, UseRtpInactivityCheck);
+		RTC::RTP::RtpStreamRecv rtpStream(
+		  std::addressof(listener), std::addressof(shared), params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(1);
 		rtpStream.ReceivePacket(packet.get());
@@ -210,7 +218,8 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 	SECTION("wrapping sequence numbers")
 	{
 		RtpStreamRecvListener listener;
-		RTC::RTP::RtpStreamRecv rtpStream(&listener, params, SendNackDelay, UseRtpInactivityCheck);
+		RTC::RTP::RtpStreamRecv rtpStream(
+		  std::addressof(listener), std::addressof(shared), params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(0xfffe);
 		rtpStream.ReceivePacket(packet.get());
@@ -230,7 +239,8 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 	SECTION("require key frame")
 	{
 		RtpStreamRecvListener listener;
-		RTC::RTP::RtpStreamRecv rtpStream(&listener, params, SendNackDelay, UseRtpInactivityCheck);
+		RTC::RTP::RtpStreamRecv rtpStream(
+		  std::addressof(listener), std::addressof(shared), params, SendNackDelay, UseRtpInactivityCheck);
 
 		packet->SetSequenceNumber(1);
 		rtpStream.ReceivePacket(packet.get());
@@ -242,7 +252,4 @@ SCENARIO("RtpStreamRecv", "[rtp][rtpstream][rtpstreamrecv]")
 		listener.shouldTriggerFIR = false;
 		rtpStream.ReceivePacket(packet.get());
 	}
-
-	// Must run the loop to wait for UV timers and close them.
-	DepLibUV::RunLoop();
 }

package/worker/test/src/RTC/RTP/TestRtpStreamSend.cpp

@@ -8,8 +8,10 @@
 #include "RTC/RTP/RtpStream.hpp"
 #include "RTC/RTP/RtpStreamSend.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
+#include "mocks/include/MockShared.hpp"
 #include <catch2/catch_test_macros.hpp>
 #include <cstring> // std::memcpy()
+#include <memory>
 #include <vector>
 
 // #define PERFORMANCE_TEST 1
@@ -104,6 +106,12 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		packet->SetPayloadDescriptorHandler(payloadDescriptorHandler);
 	};
 
+	mocks::MockShared shared(/*getTimeMs*/
+	                         []()
+	                         {
+		                         return 1000;
+	                         });
+
 	// clang-format off
 	uint8_t rtpBuffer1[] =
 	{
@@ -149,7 +157,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(&testRtpStreamListener, params, mid);
+		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(
+		  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
 
 		// Receive all the packets (some of them not in order and/or duplicated).
 		sendRtpPacket(
@@ -240,7 +249,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(&testRtpStreamListener, params, mid);
+		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(
+		  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
 
 		// Receive all the packets (some of them not in order and/or duplicated).
 		sendRtpPacket(
@@ -319,7 +329,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params.mimeType.type = RTC::RtpCodecMimeType::Type::AUDIO;
 
 		std::string mid;
-		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(&testRtpStreamListener, params, mid);
+		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(
+		  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
 
 		// Receive all the packets (some of them not in order and/or duplicated).
 		sendRtpPacket(
@@ -393,8 +404,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		std::unique_ptr<RTC::RTP::RtpStreamSend> stream1(
-		  new RTC::RTP::RtpStreamSend(&testRtpStreamListener1, params1, mid));
+		std::unique_ptr<RTC::RTP::RtpStreamSend> stream1(new RTC::RTP::RtpStreamSend(
+		  std::addressof(testRtpStreamListener1), std::addressof(shared), params1, mid));
 
 		RTC::RTP::RtpStream::Params params2;
 
@@ -403,8 +414,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params2.useNack       = true;
 		params2.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
-		std::unique_ptr<RTC::RTP::RtpStreamSend> stream2(
-		  new RTC::RTP::RtpStreamSend(&testRtpStreamListener2, params2, mid));
+		std::unique_ptr<RTC::RTP::RtpStreamSend> stream2(new RTC::RTP::RtpStreamSend(
+		  std::addressof(testRtpStreamListener2), std::addressof(shared), params2, mid));
 
 		// Receive all the packets in both streams.
 		sendRtpPacket(
@@ -504,8 +515,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		std::unique_ptr<RTC::RTP::RtpStreamSend> stream1(
-		  new RTC::RTP::RtpStreamSend(&testRtpStreamListener1, params1, mid));
+		std::unique_ptr<RTC::RTP::RtpStreamSend> stream1(new RTC::RTP::RtpStreamSend(
+		  std::addressof(testRtpStreamListener1), std::addressof(shared), params1, mid));
 
 		RTC::RTP::RtpStream::Params params2;
 
@@ -514,8 +525,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params2.useNack       = true;
 		params2.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
-		std::unique_ptr<RTC::RTP::RtpStreamSend> stream2(
-		  new RTC::RTP::RtpStreamSend(&testRtpStreamListener2, params2, mid));
+		std::unique_ptr<RTC::RTP::RtpStreamSend> stream2(new RTC::RTP::RtpStreamSend(
+		  std::addressof(testRtpStreamListener2), std::addressof(shared), params2, mid));
 
 		// Create two VP8 encoding contexts.
 		RTC::RTP::Codecs::EncodingContext::Params params;
@@ -776,8 +787,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		std::unique_ptr<RTC::RTP::RtpStreamSend> stream1(
-		  new RTC::RTP::RtpStreamSend(&testRtpStreamListener1, params1, mid));
+		std::unique_ptr<RTC::RTP::RtpStreamSend> stream1(new RTC::RTP::RtpStreamSend(
+		  std::addressof(testRtpStreamListener1), std::addressof(shared), params1, mid));
 
 		RTC::RTP::RtpStream::Params params2;
 
@@ -786,8 +797,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params2.useNack       = true;
 		params2.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
-		std::unique_ptr<RTC::RTP::RtpStreamSend> stream2(
-		  new RTC::RTP::RtpStreamSend(&testRtpStreamListener2, params2, mid));
+		std::unique_ptr<RTC::RTP::RtpStreamSend> stream2(new RTC::RTP::RtpStreamSend(
+		  std::addressof(testRtpStreamListener2), std::addressof(shared), params2, mid));
 
 		// Create two AV1 encoding contexts.
 		RTC::RTP::Codecs::EncodingContext::Params params;
@@ -920,7 +931,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(&testRtpStreamListener, params1, mid);
+		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(
+		  std::addressof(testRtpStreamListener), std::addressof(shared), params1, mid);
 
 		// Receive all the packets.
 		sendRtpPacket(
@@ -983,7 +995,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(&testRtpStreamListener, params1, mid);
+		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(
+		  std::addressof(testRtpStreamListener), std::addressof(shared), params1, mid);
 
 		// Receive all the packets.
 		sendRtpPacket(
@@ -1047,7 +1060,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params1.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(&testRtpStreamListener, params1, mid);
+		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(
+		  std::addressof(testRtpStreamListener), std::addressof(shared), params1, mid);
 
 		sendRtpPacket(
 		  {
@@ -1097,7 +1111,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(&testRtpStreamListener, params, mid);
+		auto stream = std::make_unique<RTC::RTP::RtpStreamSend>(
+		  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid);
 
 		const RTC::RTP::SharedPacket sharedPacket;
 
@@ -1124,8 +1139,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		params.mimeType.type = RTC::RtpCodecMimeType::Type::VIDEO;
 
 		std::string mid;
-		std::unique_ptr<RTC::RTP::RtpStreamSend> stream1(
-		  new RTC::RTP::RtpStreamSend(&testRtpStreamListener, params, mid));
+		std::unique_ptr<RTC::RTP::RtpStreamSend> stream1(new RTC::RTP::RtpStreamSend(
+		  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid));
 
 		size_t iterations = 10000000;
 
@@ -1146,8 +1161,8 @@ SCENARIO("RtpStreamSend", "[rtp][rtcp][nack][rtpstream][rtpstreamsend]")
 		std::cout << "nullptr && initialized shared_ptr: \t" << dur.count() << " seconds" << std::endl;
 
 		params.mimeType.type = RTC::RtpCodecMimeType::Type::AUDIO;
-		std::unique_ptr<RTC::RTP::RtpStreamSend> stream2(
-		  new RTC::RTP::RtpStreamSend(&testRtpStreamListener, params, mid));
+		std::unique_ptr<RTC::RTP::RtpStreamSend> stream2(new RTC::RTP::RtpStreamSend(
+		  std::addressof(testRtpStreamListener), std::addressof(shared), params, mid));
 
 		start = std::chrono::system_clock::now();
 

package/worker/test/src/RTC/RTP/TestSharedPacket.cpp

@@ -1,7 +1,7 @@
 #include "common.hpp"
 #include "RTC/RTP/Packet.hpp"
 #include "RTC/RTP/SharedPacket.hpp"
-#include "RTC/RTP/rtpCommon.hpp" // in worker/test/include/
+#include "test/include/RTC/RTP/rtpCommon.hpp" // in worker/test/include/
 #include <catch2/catch_test_macros.hpp>
 
 SCENARIO("RTP SharedPacket", "[rtp][sharedpacket]")

package/worker/test/src/RTC/RTP/rtpCommon.cpp

@@ -1,5 +1,5 @@
-#include "RTC/RTP/rtpCommon.hpp" // in worker/test/include/
-#include <cstring>               // std::memset
+#include "test/include/RTC/RTP/rtpCommon.hpp" // in worker/test/include/
+#include <cstring>                            // std::memset
 
 namespace rtpCommon
 {

package/worker/test/src/RTC/SCTP/association/TestHeartbeatHandler.cpp

@@ -0,0 +1,292 @@
+#include "common.hpp"
+#include "RTC/SCTP/association/HeartbeatHandler.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include "RTC/SCTP/packet/chunks/HeartbeatAckChunk.hpp"
+#include "RTC/SCTP/packet/chunks/HeartbeatRequestChunk.hpp"
+#include "RTC/SCTP/packet/parameters/HeartbeatInfoParameter.hpp"
+#include "RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp"
+#include "RTC/SCTP/public/SctpOptions.hpp"
+#include "test/include/RTC/SCTP/sctpCommon.hpp"
+#include "test/include/catch2Macros.hpp"
+#include "test/include/testHelpers.hpp"
+#include "mocks/include/MockShared.hpp"
+#include "mocks/include/RTC/SCTP/association/MockAssociationListener.hpp"
+#include "mocks/include/RTC/SCTP/association/MockTransmissionControlBlockContext.hpp"
+#include <catch2/catch_test_macros.hpp>
+#include <vector>
+
+SCENARIO("SCTP HeartbeatHandler", "[sctp][heartbeathandler]")
+{
+	constexpr uint64_t InitialNowMs{ 1000000 };
+	constexpr uint64_t HeartbeatIntervalMs{ 30000 };
+
+	class TestHeartbeatHandler
+	{
+	public:
+		explicit TestHeartbeatHandler(uint64_t heartbeatIntervalMs)
+		  // NOTE: The order in which these members are initialized is **critical**.
+		  : sctpOptions(
+		      RTC::SCTP::SctpOptions{
+		        .heartbeatIntervalMs         = heartbeatIntervalMs,
+		        .heartbeatIntervalIncludeRtt = false,
+		        .zeroChecksumAlternateErrorDetectionMethod =
+		          RTC::SCTP::ZeroChecksumAcceptableParameter::AlternateErrorDetectionMethod::NONE }),
+		    tcbContext(this->associationListener, this->sctpOptions),
+		    shared(/*getTimeMs*/
+		           [this]()
+		           {
+			           return this->nowMs;
+		           }),
+		    heartbeatHandler(
+		      this->associationListener,
+		      this->sctpOptions,
+		      std::addressof(this->shared),
+		      std::addressof(this->tcbContext))
+		{
+			// Simulate that the SCTP assiciation is connected.
+			this->tcbContext.SetAssociationEstablished(true);
+		};
+
+	public:
+		void AdvanceTimeMs(int64_t incrementMs)
+		{
+			this->nowMs += incrementMs;
+		}
+
+	private:
+		uint64_t nowMs{ InitialNowMs };
+
+		// NOTE: Public members for testing.
+	public:
+		RTC::SCTP::SctpOptions sctpOptions;
+		mocks::RTC::SCTP::MockAssociationListener associationListener;
+		mocks::RTC::SCTP::MockTransmissionControlBlockContext tcbContext;
+		mocks::MockShared shared;
+		RTC::SCTP::HeartbeatHandler heartbeatHandler;
+	};
+
+	SECTION("has running heartbeat interval timer")
+	{
+		TestHeartbeatHandler test(HeartbeatIntervalMs);
+
+		test.AdvanceTimeMs(test.sctpOptions.heartbeatIntervalMs);
+
+		auto* heartbeatIntervalTimer = test.shared.GetBackoffTimer("sctp-heartbeat-interval");
+
+		REQUIRE(heartbeatIntervalTimer);
+		REQUIRE(heartbeatIntervalTimer->EvaluateHasExpired() == true);
+		REQUIRE(test.associationListener.HasSentPackets() == true);
+
+		const std::vector<uint8_t> sentBuffer = test.associationListener.ConsumeFirstSentPacket();
+
+		std::unique_ptr<RTC::SCTP::Packet> sentPacket{ RTC::SCTP::Packet::Parse(
+			sentBuffer.data(), sentBuffer.size()) };
+
+		REQUIRE(sentPacket);
+		REQUIRE(sentPacket->GetChunksCount() == 1);
+
+		const auto* sentHeartbeatRequestChunk =
+		  sentPacket->GetFirstChunkOfType<RTC::SCTP::HeartbeatRequestChunk>();
+
+		REQUIRE(sentHeartbeatRequestChunk);
+
+		const auto* sentHeartbeatInfoParameter =
+		  sentHeartbeatRequestChunk->GetFirstParameterOfType<RTC::SCTP::HeartbeatInfoParameter>();
+
+		REQUIRE(sentHeartbeatInfoParameter);
+		REQUIRE(sentHeartbeatInfoParameter->HasInfo());
+	}
+
+	SECTION("replies to heartbeat requests")
+	{
+		TestHeartbeatHandler test(HeartbeatIntervalMs);
+
+		std::unique_ptr<RTC::SCTP::HeartbeatRequestChunk> receivedHeartbeatRequestChunk{
+			RTC::SCTP::HeartbeatRequestChunk::Factory(sctpCommon::FactoryBuffer, test.sctpOptions.mtu)
+		};
+
+		auto* receivedHeartbeatInfoParameter =
+		  receivedHeartbeatRequestChunk->BuildParameterInPlace<RTC::SCTP::HeartbeatInfoParameter>();
+
+		receivedHeartbeatInfoParameter->SetInfo(sctpCommon::DataBuffer, 10);
+		receivedHeartbeatInfoParameter->Consolidate();
+
+		test.heartbeatHandler.HandleReceivedHeartbeatRequestChunk(receivedHeartbeatRequestChunk.get());
+
+		const std::vector<uint8_t> sentBuffer = test.associationListener.ConsumeFirstSentPacket();
+
+		std::unique_ptr<RTC::SCTP::Packet> sentPacket{ RTC::SCTP::Packet::Parse(
+			sentBuffer.data(), sentBuffer.size()) };
+
+		REQUIRE(sentPacket);
+		REQUIRE(sentPacket->GetChunksCount() == 1);
+
+		const auto* sentHeartbeatAckChunk =
+		  sentPacket->GetFirstChunkOfType<RTC::SCTP::HeartbeatAckChunk>();
+
+		REQUIRE(sentHeartbeatAckChunk);
+
+		const auto* sentHeartbeatInfoParameter =
+		  sentHeartbeatAckChunk->GetFirstParameterOfType<RTC::SCTP::HeartbeatInfoParameter>();
+
+		REQUIRE(sentHeartbeatInfoParameter);
+		REQUIRE(sentHeartbeatInfoParameter->HasInfo());
+		REQUIRE(
+		  helpers::areBuffersEqual(
+		    sentHeartbeatInfoParameter->GetBuffer(),
+		    sentHeartbeatInfoParameter->GetLength(),
+		    receivedHeartbeatInfoParameter->GetBuffer(),
+		    receivedHeartbeatInfoParameter->GetLength()) == true);
+	}
+
+	SECTION("sends heartbeat requests on idle connections")
+	{
+		TestHeartbeatHandler test(HeartbeatIntervalMs);
+
+		test.AdvanceTimeMs(test.sctpOptions.heartbeatIntervalMs);
+
+		auto* heartbeatIntervalTimer = test.shared.GetBackoffTimer("sctp-heartbeat-interval");
+
+		REQUIRE(heartbeatIntervalTimer);
+		REQUIRE(heartbeatIntervalTimer->EvaluateHasExpired() == true);
+		REQUIRE(test.associationListener.HasSentPackets() == true);
+
+		const std::vector<uint8_t> sentBuffer = test.associationListener.ConsumeFirstSentPacket();
+
+		std::unique_ptr<RTC::SCTP::Packet> sentPacket{ RTC::SCTP::Packet::Parse(
+			sentBuffer.data(), sentBuffer.size()) };
+
+		REQUIRE(sentPacket);
+		REQUIRE(sentPacket->GetChunksCount() == 1);
+
+		const auto* sentHeartbeatRequestChunk =
+		  sentPacket->GetFirstChunkOfType<RTC::SCTP::HeartbeatRequestChunk>();
+
+		REQUIRE(sentHeartbeatRequestChunk);
+
+		const auto* sentHeartbeatInfoParameter =
+		  sentHeartbeatRequestChunk->GetFirstParameterOfType<RTC::SCTP::HeartbeatInfoParameter>();
+
+		REQUIRE(sentHeartbeatInfoParameter);
+		REQUIRE(sentHeartbeatInfoParameter->HasInfo());
+
+		std::unique_ptr<RTC::SCTP::HeartbeatAckChunk> receivedHeartbeatAckChunk{
+			RTC::SCTP::HeartbeatAckChunk::Factory(sctpCommon::FactoryBuffer, test.sctpOptions.mtu)
+		};
+
+		auto* receivedHeartbeatInfoParameter =
+		  receivedHeartbeatAckChunk->BuildParameterInPlace<RTC::SCTP::HeartbeatInfoParameter>();
+
+		receivedHeartbeatInfoParameter->SetInfo(
+		  sentHeartbeatInfoParameter->GetInfo(), sentHeartbeatInfoParameter->GetInfoLength());
+		receivedHeartbeatInfoParameter->Consolidate();
+
+		// Respond a while later.
+		const uint64_t rttMs{ 313 };
+
+		test.tcbContext.ExpectObserveRttMsCalledTimes(1);
+
+		test.AdvanceTimeMs(rttMs);
+		test.heartbeatHandler.HandleReceivedHeartbeatAckChunk(receivedHeartbeatAckChunk.get());
+
+		REQUIRE_VERIFICATION_RESULT(test.tcbContext.VerifyExpectations());
+	}
+
+	SECTION("doesn't observe RTT on invalid hearbeats receipt")
+	{
+		TestHeartbeatHandler test(HeartbeatIntervalMs);
+
+		test.AdvanceTimeMs(test.sctpOptions.heartbeatIntervalMs);
+
+		auto* heartbeatIntervalTimer = test.shared.GetBackoffTimer("sctp-heartbeat-interval");
+
+		REQUIRE(heartbeatIntervalTimer);
+		REQUIRE(heartbeatIntervalTimer->EvaluateHasExpired() == true);
+		REQUIRE(test.associationListener.HasSentPackets() == true);
+
+		const std::vector<uint8_t> sentBuffer = test.associationListener.ConsumeFirstSentPacket();
+
+		std::unique_ptr<RTC::SCTP::Packet> sentPacket{ RTC::SCTP::Packet::Parse(
+			sentBuffer.data(), sentBuffer.size()) };
+
+		REQUIRE(sentPacket);
+		REQUIRE(sentPacket->GetChunksCount() == 1);
+
+		const auto* sentHeartbeatRequestChunk =
+		  sentPacket->GetFirstChunkOfType<RTC::SCTP::HeartbeatRequestChunk>();
+
+		REQUIRE(sentHeartbeatRequestChunk);
+
+		const auto* sentHeartbeatInfoParameter =
+		  sentHeartbeatRequestChunk->GetFirstParameterOfType<RTC::SCTP::HeartbeatInfoParameter>();
+
+		REQUIRE(sentHeartbeatInfoParameter);
+		REQUIRE(sentHeartbeatInfoParameter->HasInfo());
+
+		std::unique_ptr<RTC::SCTP::HeartbeatAckChunk> receivedHeartbeatAckChunk{
+			RTC::SCTP::HeartbeatAckChunk::Factory(sctpCommon::FactoryBuffer, test.sctpOptions.mtu)
+		};
+
+		auto* receivedHeartbeatInfoParameter =
+		  receivedHeartbeatAckChunk->BuildParameterInPlace<RTC::SCTP::HeartbeatInfoParameter>();
+
+		receivedHeartbeatInfoParameter->SetInfo(
+		  sentHeartbeatInfoParameter->GetInfo(), sentHeartbeatInfoParameter->GetInfoLength());
+		receivedHeartbeatInfoParameter->Consolidate();
+
+		test.tcbContext.ExpectObserveRttMsCalledTimes(0);
+
+		// Go backwards in time to make the HEARTBEAT-ACK have an invalid timestamp
+		// in it, as it will be in the future.
+		test.AdvanceTimeMs(-100);
+		test.heartbeatHandler.HandleReceivedHeartbeatAckChunk(receivedHeartbeatAckChunk.get());
+
+		REQUIRE_VERIFICATION_RESULT(test.tcbContext.VerifyExpectations());
+	}
+
+	SECTION("increases error if heartbeat request is not acked in time")
+	{
+		TestHeartbeatHandler test(HeartbeatIntervalMs);
+
+		const uint64_t rtoMs{ 105 };
+
+		test.tcbContext.WillGetCurrentRtoMsOnce(
+		  []()
+		  {
+			  return rtoMs;
+		  });
+
+		test.AdvanceTimeMs(test.sctpOptions.heartbeatIntervalMs);
+
+		auto* heartbeatIntervalTimer = test.shared.GetBackoffTimer("sctp-heartbeat-interval");
+
+		REQUIRE(heartbeatIntervalTimer);
+		REQUIRE(heartbeatIntervalTimer->EvaluateHasExpired() == true);
+
+		// Validate that a request was sent.
+		REQUIRE(test.associationListener.HasSentPackets() == true);
+
+		test.tcbContext.ExpectIncrementTxErrorCounterCalledTimes(1);
+
+		test.AdvanceTimeMs(rtoMs);
+
+		auto* heartbeatTimeoutTimer = test.shared.GetBackoffTimer("sctp-heartbeat-timeout");
+
+		REQUIRE(heartbeatTimeoutTimer);
+		REQUIRE(heartbeatTimeoutTimer->EvaluateHasExpired() == true);
+		REQUIRE_VERIFICATION_RESULT(test.tcbContext.VerifyExpectations());
+	}
+
+	SECTION("doesn't send heartbeat requests when disabled")
+	{
+		TestHeartbeatHandler test(0);
+
+		test.AdvanceTimeMs(test.sctpOptions.heartbeatIntervalMs);
+
+		auto* heartbeatIntervalTimer = test.shared.GetBackoffTimer("sctp-heartbeat-interval");
+
+		REQUIRE(heartbeatIntervalTimer);
+		REQUIRE(heartbeatIntervalTimer->EvaluateHasExpired() == false);
+		REQUIRE(test.associationListener.HasSentPackets() == false);
+	}
+}

package/worker/test/src/RTC/SCTP/association/TestNegotiatedCapabilities.cpp

@@ -6,7 +6,7 @@
 #include "RTC/SCTP/packet/parameters/SupportedExtensionsParameter.hpp"
 #include "RTC/SCTP/packet/parameters/ZeroChecksumAcceptableParameter.hpp"
 #include "RTC/SCTP/public/SctpOptions.hpp"
-#include "RTC/SCTP/sctpCommon.hpp"
+#include "test/include/RTC/SCTP/sctpCommon.hpp"
 #include <catch2/catch_test_macros.hpp>
 
 SCENARIO("SCTP Negotiated Capabilities", "[sctp][negotiatedcapabilities]")

package/worker/test/src/RTC/SCTP/association/TestStateCookie.cpp

@@ -2,7 +2,7 @@
 #include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
 #include "RTC/SCTP/association/StateCookie.hpp"
 #include "RTC/SCTP/public/SctpTypes.hpp"
-#include "RTC/SCTP/sctpCommon.hpp" // in worker/test/include/
+#include "test/include/RTC/SCTP/sctpCommon.hpp" // in worker/test/include/
 #include <catch2/catch_test_macros.hpp>
 #include <cstring> // std::memset()
 

package/worker/test/src/RTC/SCTP/association/TestTransmissionControlBlock.cpp

@@ -0,0 +1,99 @@
+#include "common.hpp"
+#include "DepLibUV.hpp"
+#include "RTC/SCTP/association/NegotiatedCapabilities.hpp"
+#include "RTC/SCTP/association/PacketSender.hpp"
+#include "RTC/SCTP/association/TransmissionControlBlock.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include "RTC/SCTP/public/SctpOptions.hpp"
+#include "test/include/catch2Macros.hpp"
+#include "mocks/include/MockShared.hpp"
+#include "mocks/include/RTC/SCTP/association/MockAssociationListener.hpp"
+#include "mocks/include/RTC/SCTP/tx/MockSendQueue.hpp"
+#include <catch2/catch_test_macros.hpp>
+
+SCENARIO("SCTP TransmissionControlBlock", "[sctp][transmissioncontrolblock]")
+{
+	constexpr uint32_t LocalVerificationTag{ 123 };
+	constexpr uint32_t RemoteVerificationTag{ 456 };
+	constexpr uint32_t LocalInitialTsn{ 10 };
+	constexpr uint32_t RemoteInitialTsn{ 1000 };
+	constexpr uint32_t Arwnd{ 65536 };
+	constexpr uint64_t TieTag{ 12345678 };
+
+	class MockPacketSenderListener : public RTC::SCTP::PacketSender::Listener
+	{
+	public:
+		void OnPacketSenderPacketSent(
+		  RTC::SCTP::PacketSender* /*packetSender*/, const RTC::SCTP::Packet* /*packet*/, bool /*sent*/) override
+		{
+		}
+	};
+
+	const RTC::SCTP::SctpOptions sctpOptions;
+
+	mocks::RTC::SCTP::MockAssociationListener associationListener;
+	mocks::MockShared shared(/*getTimeMs*/
+	                         []()
+	                         {
+		                         return DepLibUV::GetTimeMs();
+	                         });
+	mocks::RTC::SCTP::MockSendQueue sendQueue;
+	RTC::SCTP::NegotiatedCapabilities negotiatedCapabilities;
+	MockPacketSenderListener packetSenderListener;
+	RTC::SCTP::PacketSender packetSender(std::addressof(packetSenderListener), associationListener);
+
+	auto isAssociationEstablished = []()
+	{
+		return true;
+	};
+
+	SECTION("without message interleaving")
+	{
+		negotiatedCapabilities.messageInterleaving = false;
+
+		sendQueue.ExpectEnableMessageInterleavingCalledWith(false);
+
+		const RTC::SCTP::TransmissionControlBlock tcb(
+		  associationListener,
+		  sctpOptions,
+		  std::addressof(shared),
+		  sendQueue,
+		  packetSender,
+		  LocalVerificationTag,
+		  RemoteVerificationTag,
+		  LocalInitialTsn,
+		  RemoteInitialTsn,
+		  Arwnd,
+		  TieTag,
+		  negotiatedCapabilities,
+		  /*maxPacketLength*/ 1200,
+		  isAssociationEstablished);
+
+		REQUIRE_VERIFICATION_RESULT(sendQueue.VerifyExpectations());
+	}
+
+	SECTION("with message interleaving")
+	{
+		negotiatedCapabilities.messageInterleaving = true;
+
+		sendQueue.ExpectEnableMessageInterleavingCalledWith(true);
+
+		const RTC::SCTP::TransmissionControlBlock tcb(
+		  associationListener,
+		  sctpOptions,
+		  std::addressof(shared),
+		  sendQueue,
+		  packetSender,
+		  LocalVerificationTag,
+		  RemoteVerificationTag,
+		  LocalInitialTsn,
+		  RemoteInitialTsn,
+		  Arwnd,
+		  TieTag,
+		  negotiatedCapabilities,
+		  /*maxPacketLength*/ 1200,
+		  isAssociationEstablished);
+
+		REQUIRE_VERIFICATION_RESULT(sendQueue.VerifyExpectations());
+	}
+}