mediasoup 3.19.21 → 3.20.0

package/worker/src/Worker.cpp

@@ -2,23 +2,20 @@
 // #define MS_LOG_DEV_LEVEL 3
 
 #include "Worker.hpp"
-#include "ChannelMessageRegistrator.hpp"
 #ifdef MS_LIBURING_SUPPORTED
 #include "DepLibUring.hpp"
 #endif
+#include "FBS/response.h"
+#include "FBS/worker.h"
 #include "DepLibUV.hpp"
-// TODO: Remove once we only use built-in SCTP stack.
-#include "DepUsrSCTP.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
 #include "Settings.hpp"
-#include "Channel/ChannelNotifier.hpp"
-#include "FBS/response.h"
-#include "FBS/worker.h"
 
 /* Instance methods. */
 
-Worker::Worker(::Channel::ChannelSocket* channel) : channel(channel)
+Worker::Worker(::Channel::ChannelSocket* channel, SharedInterface* shared)
+  : channel(channel), shared(shared)
 {
 	MS_TRACE();
 
@@ -28,11 +25,6 @@ Worker::Worker(::Channel::ChannelSocket* channel) : channel(channel)
 	// Set the SignalHandle.
 	this->signalHandle = new SignalHandle(this);
 
-	// Set up the RTC::Shared singleton.
-	this->shared = new RTC::Shared(
-	  /*channelMessageRegistrator*/ new ChannelMessageRegistrator(),
-	  /*channelNotifier*/ new Channel::ChannelNotifier(this->channel));
-
 #ifdef MS_EXECUTABLE
 	{
 		// Add signals to handle.
@@ -41,13 +33,6 @@ Worker::Worker(::Channel::ChannelSocket* channel) : channel(channel)
 	}
 #endif
 
-	// TODO: Remove once we only use built-in SCTP stack.
-	if (!Settings::configuration.useBuiltInSctpStack)
-	{
-		// Create the Checker instance in DepUsrSCTP.
-		DepUsrSCTP::CreateChecker();
-	}
-
 #ifdef MS_LIBURING_SUPPORTED
 	if (DepLibUring::IsEnabled())
 	{
@@ -57,8 +42,8 @@ Worker::Worker(::Channel::ChannelSocket* channel) : channel(channel)
 #endif
 
 	// Tell the Node process that we are running.
-	this->shared->channelNotifier->Emit(
-	  std::to_string(Logger::pid), FBS::Notification::Event::WORKER_RUNNING);
+	this->shared->GetChannelNotifier()->Emit(
+	  std::to_string(Logger::Pid), FBS::Notification::Event::WORKER_RUNNING);
 
 	MS_DEBUG_DEV("starting libuv loop");
 	DepLibUV::RunLoop();
@@ -107,16 +92,6 @@ void Worker::Close()
 	}
 	this->mapWebRtcServers.clear();
 
-	// Delete the RTC::Shared singleton.
-	delete this->shared;
-
-	// TODO: Remove once we only use built-in SCTP stack.
-	if (!Settings::configuration.useBuiltInSctpStack)
-	{
-		// Close the Checker instance in DepUsrSCTP.
-		DepUsrSCTP::CloseChecker();
-	}
-
 #ifdef MS_LIBURING_SUPPORTED
 	if (DepLibUring::IsEnabled())
 	{
@@ -155,14 +130,14 @@ flatbuffers::Offset<FBS::Worker::DumpResponse> Worker::FillBuffer(
 	}
 
 	// Add channelMessageHandlers.
-	auto channelMessageHandlers = this->shared->channelMessageRegistrator->FillBuffer(builder);
+	auto channelMessageHandlers = this->shared->GetChannelMessageRegistrator()->FillBuffer(builder);
 
 #ifdef MS_LIBURING_SUPPORTED
 	if (DepLibUring::IsEnabled())
 	{
 		return FBS::Worker::CreateDumpResponseDirect(
 		  builder,
-		  Logger::pid,
+		  Logger::Pid,
 		  &webRtcServerIds,
 		  &routerIds,
 		  channelMessageHandlers,
@@ -171,11 +146,11 @@ flatbuffers::Offset<FBS::Worker::DumpResponse> Worker::FillBuffer(
 	else
 	{
 		return FBS::Worker::CreateDumpResponseDirect(
-		  builder, Logger::pid, &webRtcServerIds, &routerIds, channelMessageHandlers);
+		  builder, Logger::Pid, &webRtcServerIds, &routerIds, channelMessageHandlers);
 	}
 #else
 	return FBS::Worker::CreateDumpResponseDirect(
-	  builder, Logger::pid, &webRtcServerIds, &routerIds, channelMessageHandlers);
+	  builder, Logger::Pid, &webRtcServerIds, &routerIds, channelMessageHandlers);
 #endif
 }
 
@@ -241,7 +216,7 @@ flatbuffers::Offset<FBS::Worker::ResourceUsageResponse> Worker::FillBufferResour
 	  uvRusage.ru_nivcsw);
 }
 
-RTC::WebRtcServer* Worker::GetWebRtcServer(const std::string& webRtcServerId) const
+RTC::WebRtcServer* Worker::AssertAndGetWebRtcServerById(const std::string& webRtcServerId) const
 {
 	auto it = this->mapWebRtcServers.find(webRtcServerId);
 
@@ -253,7 +228,7 @@ RTC::WebRtcServer* Worker::GetWebRtcServer(const std::string& webRtcServerId) co
 	return it->second;
 }
 
-RTC::Router* Worker::GetRouter(const std::string& routerId) const
+RTC::Router* Worker::AssertAndGetRouterById(const std::string& routerId) const
 {
 	MS_TRACE();
 
@@ -357,7 +332,7 @@ void Worker::HandleRequest(Channel::ChannelRequest* request)
 
 			try
 			{
-				webRtcServer = GetWebRtcServer(webRtcServerId);
+				webRtcServer = AssertAndGetWebRtcServerById(webRtcServerId);
 			}
 			catch (const MediaSoupError& error)
 			{
@@ -412,7 +387,7 @@ void Worker::HandleRequest(Channel::ChannelRequest* request)
 
 			try
 			{
-				router = GetRouter(routerId);
+				router = AssertAndGetRouterById(routerId);
 			}
 			catch (const MediaSoupError& error)
 			{
@@ -437,7 +412,7 @@ void Worker::HandleRequest(Channel::ChannelRequest* request)
 			try
 			{
 				auto* handler =
-				  this->shared->channelMessageRegistrator->GetChannelRequestHandler(request->handlerId);
+				  this->shared->GetChannelMessageRegistrator()->GetChannelRequestHandler(request->handlerId);
 
 				if (handler == nullptr)
 				{
@@ -486,7 +461,7 @@ void Worker::HandleNotification(Channel::ChannelNotification* notification)
 		{
 			try
 			{
-				auto* handler = this->shared->channelMessageRegistrator->GetChannelNotificationHandler(
+				auto* handler = this->shared->GetChannelMessageRegistrator()->GetChannelNotificationHandler(
 				  notification->handlerId);
 
 				if (handler == nullptr)
@@ -513,7 +488,8 @@ void Worker::OnChannelClosed(Channel::ChannelSocket* /*socket*/)
 {
 	MS_TRACE_STD();
 
-	// Only needed for executable, library user can close channel earlier and it is fine.
+	// Only needed for executable, library user can close channel earlier and it
+	// is fine.
 #ifdef MS_EXECUTABLE
 	// If the pipe is remotely closed it may mean that mediasoup Node process
 	// abruptly died (SIGKILL?) so we must die.
@@ -537,11 +513,6 @@ void Worker::OnSignal(SignalHandle* /*signalHandle*/, int signum)
 		case SIGINT:
 		case SIGTERM:
 		{
-			if (this->closed)
-			{
-				return;
-			}
-
 			MS_DEBUG_DEV("%s signal received, closing myself", signum == SIGINT ? "INT" : "TERM");
 
 			Close();
@@ -551,7 +522,7 @@ void Worker::OnSignal(SignalHandle* /*signalHandle*/, int signum)
 
 		default:
 		{
-			MS_WARN_DEV("received a non handled signal [signum:%d]", signum);
+			MS_WARN_DEV("ignoring received non handled signal [signum:%d]", signum);
 		}
 	}
 }

package/worker/src/handles/BackoffTimerHandle.cpp

@@ -8,22 +8,34 @@
 
 /* Instance methods. */
 
-BackoffTimerHandle::BackoffTimerHandle(
-  Listener* listener,
-  uint64_t baseTimeoutMs,
-  BackoffAlgorithm backoffAlgorithm,
-  std::optional<uint64_t> maxBackoffTimeoutMs,
-  std::optional<size_t> maxRestarts)
-  : listener(listener),
-    baseTimeoutMs(baseTimeoutMs),
-    backoffAlgorithm(backoffAlgorithm),
-    maxBackoffTimeoutMs(maxBackoffTimeoutMs),
-    maxRestarts(maxRestarts)
+BackoffTimerHandle::BackoffTimerHandle(BackoffTimerHandleOptions options)
+  : listener(options.listener),
+    label(std::move(options.label)),
+    baseTimeoutMs(options.baseTimeoutMs),
+    backoffAlgorithm(options.backoffAlgorithm),
+    maxBackoffTimeoutMs(options.maxBackoffTimeoutMs),
+    maxRestarts(options.maxRestarts)
 {
 	MS_TRACE();
 
-	// NOTE: This may throw.
-	SetBaseTimeoutMs(baseTimeoutMs);
+	if (!this->listener)
+	{
+		MS_THROW_TYPE_ERROR("options.listener must be given");
+	}
+
+	if (this->label.empty())
+	{
+		MS_THROW_TYPE_ERROR("options.label must be given");
+	}
+
+	if (this->baseTimeoutMs > BackoffTimerHandleInterface::MaxTimeoutMs)
+	{
+		MS_THROW_ERROR(
+		  "[%s] base timeout (%" PRIu64 " ms) cannot be greater than %" PRIu64 " ms",
+		  this->label.c_str(),
+		  this->baseTimeoutMs,
+		  BackoffTimerHandleInterface::MaxTimeoutMs);
+	}
 
 	this->timer = new TimerHandle(this);
 }
@@ -60,12 +72,13 @@ void BackoffTimerHandle::SetBaseTimeoutMs(uint64_t baseTimeoutMs)
 {
 	MS_TRACE();
 
-	if (baseTimeoutMs > BackoffTimerHandle::MaxTimeoutMs)
+	if (baseTimeoutMs > BackoffTimerHandleInterface::MaxTimeoutMs)
 	{
 		MS_THROW_ERROR(
-		  "base timeout (%" PRIu64 " ms) cannot be greater than %" PRIu64 " ms",
+		  "[%s] base timeout (%" PRIu64 " ms) cannot be greater than %" PRIu64 " ms",
+		  this->label.c_str(),
 		  baseTimeoutMs,
-		  BackoffTimerHandle::MaxTimeoutMs);
+		  BackoffTimerHandleInterface::MaxTimeoutMs);
 	}
 
 	this->baseTimeoutMs = baseTimeoutMs;
@@ -88,7 +101,7 @@ uint64_t BackoffTimerHandle::ComputeNextTimeoutMs() const
 		{
 			auto timeoutMs = this->baseTimeoutMs;
 
-			while (expirationCount > 0 && timeoutMs < BackoffTimerHandle::MaxTimeoutMs)
+			while (expirationCount > 0 && timeoutMs < BackoffTimerHandleInterface::MaxTimeoutMs)
 			{
 				timeoutMs *= 2;
 				--expirationCount;
@@ -99,21 +112,21 @@ uint64_t BackoffTimerHandle::ComputeNextTimeoutMs() const
 				}
 			}
 
-			return std::min<uint64_t>(timeoutMs, BackoffTimerHandle::MaxTimeoutMs);
+			return std::min<uint64_t>(timeoutMs, BackoffTimerHandleInterface::MaxTimeoutMs);
 		}
 
 			NO_DEFAULT_GCC();
 	}
 }
 
-void BackoffTimerHandle::OnTimer(TimerHandle* timer)
+void BackoffTimerHandle::OnTimer(TimerHandleInterface* /*timer*/)
 {
 	MS_TRACE();
 
 	this->expirationCount++;
 
 	// Compute whether the BackoffTimer should still be running after this timeout
-	// expiration so the parent can check IsRunning() within the OnTimer()
+	// expiration so the parent can check IsRunning() within the `OnBackoffTimer()`
 	// callback.
 	this->running =
 	  !this->maxRestarts.has_value() || this->expirationCount <= this->maxRestarts.value();
@@ -123,7 +136,7 @@ void BackoffTimerHandle::OnTimer(TimerHandle* timer)
 
 	// Call the listener by passing base timeout as reference so the parent has
 	// a chance to change it and affect the next timeout.
-	this->listener->OnTimer(this, baseTimeoutMs, stop);
+	this->listener->OnBackoffTimer(this, baseTimeoutMs, stop);
 
 	// If the parent has set `stop` to true it means that it has deleted the
 	// instance, so stop here.

package/worker/src/handles/TimerHandle.cpp

@@ -8,19 +8,20 @@
 
 /* Static methods for UV callbacks. */
 
-inline static void onTimer(uv_timer_t* handle)
+static void onTimer(uv_timer_t* handle)
 {
 	static_cast<TimerHandle*>(handle->data)->OnUvTimer();
 }
 
-inline static void onCloseTimer(uv_handle_t* handle)
+static void onCloseTimer(uv_handle_t* handle)
 {
 	delete reinterpret_cast<uv_timer_t*>(handle);
 }
 
 /* Instance methods. */
 
-TimerHandle::TimerHandle(Listener* listener) : listener(listener), uvHandle(new uv_timer_t)
+TimerHandle::TimerHandle(TimerHandleInterface::Listener* listener)
+  : listener(listener), uvHandle(new uv_timer_t)
 {
 	MS_TRACE();
 
@@ -174,7 +175,7 @@ void TimerHandle::InternalClose()
 	uv_close(reinterpret_cast<uv_handle_t*>(this->uvHandle), static_cast<uv_close_cb>(onCloseTimer));
 }
 
-inline void TimerHandle::OnUvTimer()
+void TimerHandle::OnUvTimer()
 {
 	MS_TRACE();
 

package/worker/src/handles/UdpSocketHandle.cpp

@@ -17,7 +17,7 @@ static constexpr size_t ReadBufferSize{ 65536 };
 // it to structs (e.g. RTP::Packet::FixedHeader) that require 4-byte alignment.
 // Without this, accessing multi-byte fields would be undefined behavior on
 // strict-alignment architectures.
-alignas(4) thread_local uint8_t ReadBuffer[ReadBufferSize];
+alignas(4) static thread_local uint8_t ReadBuffer[ReadBufferSize];
 
 /* Static methods for UV callbacks. */
 

package/worker/src/lib.cpp

@@ -1,24 +1,26 @@
 #define MS_CLASS "mediasoup-worker"
 // #define MS_LOG_DEV_LEVEL 3
 
+#include "lib.hpp"
 #include "common.hpp"
 #include "DepLibSRTP.hpp"
 #ifdef MS_LIBURING_SUPPORTED
 #include "DepLibUring.hpp"
 #endif
+#include "Channel/ChannelMessageRegistrator.hpp"
+#include "Channel/ChannelNotifier.hpp"
+#include "Channel/ChannelSocket.hpp"
 #include "DepLibUV.hpp"
 #include "DepLibWebRTC.hpp"
 #include "DepOpenSSL.hpp"
-// TODO: Remove once we only use built-in SCTP stack.
-#include "DepUsrSCTP.hpp"
 #include "Logger.hpp"
 #include "MediaSoupErrors.hpp"
+#include "RTC/DtlsTransport.hpp"
+#include "RTC/SrtpSession.hpp"
 #include "Settings.hpp"
+#include "Shared.hpp"
 #include "Utils.hpp"
 #include "Worker.hpp"
-#include "Channel/ChannelSocket.hpp"
-#include "RTC/DtlsTransport.hpp"
-#include "RTC/SrtpSession.hpp"
 #include <absl/container/flat_hash_map.h>
 #include <csignal> // sigaction()
 #include <string>
@@ -82,6 +84,11 @@ extern "C" int mediasoup_worker_run(
 	}
 #endif
 
+	// Create a Shared singleton.
+	std::unique_ptr<Shared> shared{ new Shared(
+		/*channelMessageRegistrator*/ new Channel::ChannelMessageRegistrator(),
+		/*channelNotifier*/ new Channel::ChannelNotifier(channel.get())) };
+
 	// Initialize the Logger.
 	Logger::ClassInit(channel.get());
 
@@ -147,11 +154,6 @@ extern "C" int mediasoup_worker_run(
 		// Initialize static stuff.
 		DepOpenSSL::ClassInit();
 		DepLibSRTP::ClassInit();
-		// TODO: Remove once we only use built-in SCTP stack.
-		if (!Settings::configuration.useBuiltInSctpStack)
-		{
-			DepUsrSCTP::ClassInit();
-		}
 #ifdef MS_LIBURING_SUPPORTED
 		DepLibUring::ClassInit();
 #endif
@@ -163,8 +165,12 @@ extern "C" int mediasoup_worker_run(
 		// Ignore some signals.
 		ignoreSignals();
 
+		MS_DEBUG_TAG(info, "creating Worker instance");
+
 		// Run the Worker.
-		const Worker worker(channel.get());
+		const Worker worker(channel.get(), shared.get());
+
+		MS_DEBUG_TAG(info, "Worker instance terminated");
 
 		// Free static stuff.
 		DepLibSRTP::ClassDestroy();
@@ -174,11 +180,6 @@ extern "C" int mediasoup_worker_run(
 		DepLibUring::ClassDestroy();
 #endif
 		RTC::DtlsTransport::ClassDestroy();
-		// TODO: Remove once we only use built-in SCTP stack.
-		if (!Settings::configuration.useBuiltInSctpStack)
-		{
-			DepUsrSCTP::ClassDestroy();
-		}
 		DepLibUV::ClassDestroy();
 
 		return 0;

package/worker/subprojects/catch2.wrap

@@ -1,10 +1,10 @@
 [wrap-file]
-directory = Catch2-3.13.0
-source_url = https://github.com/catchorg/Catch2/archive/v3.13.0.tar.gz
-source_filename = Catch2-3.13.0.tar.gz
-source_hash = 650795f6501af514f806e78c554729847b98db6935e69076f36bb03ed2e985ef
-source_fallback_url = https://wrapdb.mesonbuild.com/v2/catch2_3.13.0-1/get_source/Catch2-3.13.0.tar.gz
-wrapdb_version = 3.13.0-1
+directory = Catch2-3.14.0
+source_url = https://github.com/catchorg/Catch2/archive/v3.14.0.tar.gz
+source_filename = Catch2-3.14.0.tar.gz
+source_hash = ba2a939efead3c833c499cf487e185762f419a71d30158cd1b43c6079c586490
+source_fallback_url = https://wrapdb.mesonbuild.com/v2/catch2_3.14.0-1/get_source/Catch2-3.14.0.tar.gz
+wrapdb_version = 3.14.0-1
 
 [provide]
 catch2 = catch2_dep

package/worker/tasks.py

@@ -496,7 +496,7 @@ def test_asan_undefined(ctx):
         );
 
 
-@task(pre=[call(setup, meson_args=MESON_ARGS + ' -Db_sanitize=address -Db_lundef=false'), flatc])
+@task(pre=[call(setup, meson_args=MESON_ARGS + ' -Dms_build_fuzzer=true -Db_sanitize=address -Db_lundef=false'), flatc])
 def fuzzer(ctx):
     """
     Build the mediasoup-worker-fuzzer binary (which uses libFuzzer)

package/worker/test/include/RTC/ICE/iceCommon.hpp

@@ -2,13 +2,13 @@
 #define MS_TEST_RTC_ICE_COMMON_HPP
 
 #include "common.hpp"
-#include "MediaSoupErrors.hpp"          // IWYU pragma: export
-#include "Utils.hpp"                    // IWYU pragma: export
-#include "testHelpers.hpp"              // IWYU pragma: export
-#include "RTC/ICE/StunPacket.hpp"       // IWYU pragma: export
-#include <catch2/catch_test_macros.hpp> // IWYU pragma: export
-#include <cstdlib>                      // std::malloc(), std::free()
-#include <cstring>                      // std::memcpy()
+#include "MediaSoupErrors.hpp"
+#include "RTC/ICE/StunPacket.hpp"
+#include "Utils.hpp"
+#include "test/include/testHelpers.hpp"
+#include <catch2/catch_test_macros.hpp>
+#include <cstdlib> // std::malloc(), std::free()
+#include <cstring> // std::memcpy()
 #include <string_view>
 
 namespace iceCommon
@@ -65,6 +65,7 @@ namespace iceCommon
 		REQUIRE(packet->GetBufferLength() == bufferLength);                                               \
 		REQUIRE(packet->GetLength() != 0);                                                                \
 		REQUIRE(packet->GetLength() == length);                                                           \
+		REQUIRE(packet->GetAvailableLength() == packet->GetBufferLength() - packet->GetLength());         \
 		REQUIRE(packet->GetClass() == klass);                                                             \
 		REQUIRE(packet->GetMethod() == method);                                                           \
 		REQUIRE(packet->HasAttribute(RTC::ICE::StunPacket::AttributeType::USERNAME) == hasUsername);      \

package/worker/test/include/RTC/RTP/rtpCommon.hpp

@@ -2,12 +2,12 @@
 #define MS_TEST_RTC_RTP_COMMON_HPP
 
 #include "common.hpp"
-#include "MediaSoupErrors.hpp"          // IWYU pragma: export
-#include "testHelpers.hpp"              // IWYU pragma: export
-#include "RTC/RTP/Packet.hpp"           // IWYU pragma: export
-#include <catch2/catch_test_macros.hpp> // IWYU pragma: export
-#include <cstdlib>                      // std::malloc(), std::free()
-#include <cstring>                      // std::memcpy()
+#include "MediaSoupErrors.hpp"
+#include "RTC/RTP/Packet.hpp"
+#include "test/include/testHelpers.hpp"
+#include <catch2/catch_test_macros.hpp>
+#include <cstdlib> // std::malloc(), std::free()
+#include <cstring> // std::memcpy()
 
 namespace rtpCommon
 {
@@ -55,6 +55,7 @@ namespace rtpCommon
 		REQUIRE(packet->GetBufferLength() == bufferLength);                                              \
 		REQUIRE(packet->GetLength() != 0);                                                               \
 		REQUIRE(packet->GetLength() == length);                                                          \
+		REQUIRE(packet->GetAvailableLength() == packet->GetBufferLength() - packet->GetLength());        \
 		REQUIRE(static_cast<unsigned>(packet->GetVersion()) == 2);                                       \
 		REQUIRE(static_cast<unsigned>(packet->GetPayloadType()) == payloadType);                         \
 		REQUIRE(packet->HasMarker() == hasMarker);                                                       \

package/worker/test/include/RTC/SCTP/sctpCommon.hpp

@@ -2,16 +2,16 @@
 #define MS_TEST_RTC_SCTP_COMMON_HPP
 
 #include "common.hpp"
-#include "MediaSoupErrors.hpp"                                               // IWYU pragma: export
-#include "Utils.hpp"                                                         // IWYU pragma: export
-#include "testHelpers.hpp"                                                   // IWYU pragma: export
-#include "RTC/SCTP/packet/Chunk.hpp"                                         // IWYU pragma: export
-#include "RTC/SCTP/packet/ErrorCause.hpp"                                    // IWYU pragma: export
-#include "RTC/SCTP/packet/Packet.hpp"                                        // IWYU pragma: export
-#include "RTC/SCTP/packet/Parameter.hpp"                                     // IWYU pragma: export
-#include "RTC/SCTP/packet/errorCauses/InvalidStreamIdentifierErrorCause.hpp" // IWYU pragma: export
-#include "RTC/SCTP/packet/parameters/HeartbeatInfoParameter.hpp"             // IWYU pragma: export
-#include <catch2/catch_test_macros.hpp>                                      // IWYU pragma: export
+#include "MediaSoupErrors.hpp"
+#include "RTC/SCTP/packet/Chunk.hpp"
+#include "RTC/SCTP/packet/ErrorCause.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include "RTC/SCTP/packet/Parameter.hpp"
+#include "RTC/SCTP/packet/errorCauses/InvalidStreamIdentifierErrorCause.hpp"
+#include "RTC/SCTP/packet/parameters/HeartbeatInfoParameter.hpp"
+#include "Utils.hpp"
+#include "test/include/testHelpers.hpp"
+#include <catch2/catch_test_macros.hpp>
 
 namespace sctpCommon
 {
@@ -49,6 +49,7 @@ namespace sctpCommon
 		REQUIRE(packet->GetBufferLength() == bufferLength);                                            \
 		REQUIRE(packet->GetLength() != 0);                                                             \
 		REQUIRE(packet->GetLength() == length);                                                        \
+		REQUIRE(packet->GetAvailableLength() == packet->GetBufferLength() - packet->GetLength());      \
 		REQUIRE(Utils::Byte::IsPaddedTo4Bytes(packet->GetLength()) == true);                           \
 		REQUIRE(packet->GetSourcePort() == sourcePort);                                                \
 		REQUIRE(packet->GetDestinationPort() == destinationPort);                                      \
@@ -92,6 +93,7 @@ namespace sctpCommon
 		REQUIRE(chunk->GetBufferLength() == bufferLength);                                             \
 		REQUIRE(chunk->GetLength() != 0);                                                              \
 		REQUIRE(chunk->GetLength() == length);                                                         \
+		REQUIRE(chunk->GetAvailableLength() == chunk->GetBufferLength() - chunk->GetLength());         \
 		REQUIRE(Utils::Byte::IsPaddedTo4Bytes(chunk->GetLength()) == true);                            \
 		REQUIRE(chunk->GetType() == chunkType);                                                        \
 		REQUIRE(chunk->HasUnknownType() == unknownType);                                               \
@@ -152,6 +154,8 @@ namespace sctpCommon
 		REQUIRE(parameter->GetBufferLength() == bufferLength);                                          \
 		REQUIRE(parameter->GetLength() != 0);                                                           \
 		REQUIRE(parameter->GetLength() == length);                                                      \
+		REQUIRE(                                                                                        \
+		  parameter->GetAvailableLength() == parameter->GetBufferLength() - parameter->GetLength());    \
 		REQUIRE(Utils::Byte::IsPaddedTo4Bytes(parameter->GetLength()) == true);                         \
 		REQUIRE(parameter->GetType() == parameterType);                                                 \
 		REQUIRE(parameter->HasUnknownType() == unknownType);                                            \
@@ -189,6 +193,8 @@ namespace sctpCommon
 		REQUIRE(errorCause->GetBufferLength() == bufferLength);                                          \
 		REQUIRE(errorCause->GetLength() != 0);                                                           \
 		REQUIRE(errorCause->GetLength() == length);                                                      \
+		REQUIRE(                                                                                         \
+		  errorCause->GetAvailableLength() == errorCause->GetBufferLength() - errorCause->GetLength());  \
 		REQUIRE(Utils::Byte::IsPaddedTo4Bytes(errorCause->GetLength()) == true);                         \
 		REQUIRE(errorCause->GetCode() == causeCode);                                                     \
 		REQUIRE(errorCause->HasUnknownCode() == unknownCode);                                            \

package/worker/test/include/catch2Macros.hpp

@@ -0,0 +1,31 @@
+#ifndef MS_CATCH2_MACROS_HPP
+#define MS_CATCH2_MACROS_HPP
+
+#include <catch2/catch_test_macros.hpp>
+
+/**
+ * `VerificationResult` struct is defined in mocks/include/mockTypes.hpp.
+ */
+// clang-format off
+#define REQUIRE_VERIFICATION_RESULT(verificationResult) \
+	do \
+	{ \
+		const auto& result = (verificationResult); \
+		\
+		if (!(result.ok)) \
+		{ \
+			FAIL(result.errorMessage); \
+		} \
+	} while (false)
+
+// clang-format off
+#define REQUIRE_WITH_MESSAGE(condition, errorMessage) \
+	do \
+	{ \
+		if (!(condition)) \
+		{ \
+			FAIL(errorMessage); \
+		} \
+	} while (false)
+
+#endif

package/worker/test/src/RTC/ICE/TestStunPacket.cpp

@@ -1,8 +1,8 @@
 #include "common.hpp"
-#include "Utils.hpp"
-#include "testHelpers.hpp"
 #include "RTC/ICE/StunPacket.hpp"
-#include "RTC/ICE/iceCommon.hpp"
+#include "Utils.hpp"
+#include "test/include/RTC/ICE/iceCommon.hpp"
+#include "test/include/testHelpers.hpp"
 #include <uv.h>
 #include <catch2/catch_test_macros.hpp>
 #include <cstring> // std::memset()

package/worker/test/src/RTC/ICE/iceCommon.cpp

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

package/worker/test/src/RTC/RTP/Codecs/TestVP8.cpp

@@ -1,7 +1,7 @@
 #include "common.hpp"
 #include "RTC/RTP/Codecs/VP8.hpp"
 #include "RTC/RTP/Packet.hpp"
-#include "RTC/RTP/rtpCommon.hpp"
+#include "test/include/RTC/RTP/rtpCommon.hpp"
 #include <catch2/catch_test_macros.hpp>
 #include <cstring> // std::memcmp(), std::memcpy()
 

package/worker/test/src/RTC/RTP/Codecs/TestVP9.cpp

@@ -1,7 +1,7 @@
 #include "common.hpp"
 #include "RTC/RTP/Codecs/VP9.hpp"
 #include "RTC/RTP/Packet.hpp"
-#include "RTC/RTP/rtpCommon.hpp"
+#include "test/include/RTC/RTP/rtpCommon.hpp"
 #include <catch2/catch_test_macros.hpp>
 #include <cstring> // std::memcmp()
 

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

@@ -1,10 +1,10 @@
 #include "common.hpp"
-#include "Utils.hpp"
-#include "testHelpers.hpp"
 #include "RTC/RTP/HeaderExtensionIds.hpp"
 #include "RTC/RTP/Packet.hpp"
-#include "RTC/RTP/rtpCommon.hpp"
 #include "RTC/RtpDictionaries.hpp"
+#include "Utils.hpp"
+#include "test/include/RTC/RTP/rtpCommon.hpp"
+#include "test/include/testHelpers.hpp"
 #include <catch2/catch_test_macros.hpp>
 #include <cstring> // std::memset()
 #include <string>