mediasoup 3.19.21 → 3.20.0

package/worker/meson.build

@@ -33,6 +33,13 @@ if get_option('ms_build_tests')
   ]
 endif
 
+if get_option('ms_build_fuzzer')
+  cpp_args += [
+    '-DMS_FUZZER',
+    '-DMS_LOG_STD'
+  ]
+endif
+
 if get_option('ms_log_trace')
   cpp_args += [
     '-DMS_LOG_TRACE',
@@ -81,13 +88,11 @@ common_sources = [
   'src/DepLibUV.cpp',
   'src/DepLibWebRTC.cpp',
   'src/DepOpenSSL.cpp',
-  # TODO: Remove once we only use built-in SCTP stack.
-  'src/DepUsrSCTP.cpp',
   'src/Logger.cpp',
   'src/MediaSoupErrors.cpp',
   'src/Settings.cpp',
+  'src/Shared.cpp',
   'src/Worker.cpp',
-  'src/ChannelMessageRegistrator.cpp',
   'src/Utils/BitStream.cpp',
   'src/Utils/Crypto.cpp',
   'src/Utils/File.cpp',
@@ -102,6 +107,7 @@ common_sources = [
   'src/handles/UnixStreamSocketHandle.cpp',
   'src/Channel/ChannelNotifier.cpp',
   'src/Channel/ChannelRequest.cpp',
+  'src/Channel/ChannelMessageRegistrator.cpp',
   'src/Channel/ChannelNotification.cpp',
   'src/Channel/ChannelSocket.cpp',
   'src/RTC/ActiveSpeakerObserver.cpp',
@@ -123,13 +129,10 @@ common_sources = [
   'src/RTC/RtcLogger.cpp',
   'src/RTC/RtpListener.cpp',
   'src/RTC/RtpObserver.cpp',
-  # TODO: Remove once we only use built-in SCTP stack.
-  'src/RTC/SctpAssociation.cpp',
   'src/RTC/SctpListener.cpp',
   'src/RTC/SenderBandwidthEstimator.cpp',
   'src/RTC/SeqManager.cpp',
   'src/RTC/Serializable.cpp',
-  'src/RTC/Shared.cpp',
   'src/RTC/SimpleConsumer.cpp',
   'src/RTC/SimulcastConsumer.cpp',
   'src/RTC/SrtpSession.cpp',
@@ -207,8 +210,16 @@ common_sources = [
   'src/RTC/SCTP/association/StateCookie.cpp',
   'src/RTC/SCTP/association/StreamResetHandler.cpp',
   'src/RTC/SCTP/association/TransmissionControlBlock.cpp',
+  'src/RTC/SCTP/rx/DataTracker.cpp',
+  'src/RTC/SCTP/rx/InterleavedReassemblyStreams.cpp',
+  'src/RTC/SCTP/rx/ReassemblyQueue.cpp',
+  'src/RTC/SCTP/rx/TraditionalReassemblyStreams.cpp',
+  'src/RTC/SCTP/tx/OutstandingData.cpp',
   'src/RTC/SCTP/tx/RetransmissionErrorCounter.cpp',
+  'src/RTC/SCTP/tx/RetransmissionQueue.cpp',
   'src/RTC/SCTP/tx/RetransmissionTimeout.cpp',
+  'src/RTC/SCTP/tx/RoundRobinSendQueue.cpp',
+  'src/RTC/SCTP/tx/StreamScheduler.cpp',
   'src/RTC/SCTP/packet/Packet.cpp',
   'src/RTC/SCTP/packet/TLV.cpp',
   'src/RTC/SCTP/packet/UserData.cpp',
@@ -265,6 +276,7 @@ common_sources = [
   'src/RTC/SCTP/packet/errorCauses/ProtocolViolationErrorCause.cpp',
   'src/RTC/SCTP/packet/errorCauses/UnknownErrorCause.cpp',
   'src/RTC/SCTP/public/AssociationMetrics.cpp',
+  'src/RTC/SCTP/public/SctpOptions.cpp',
   'src/RTC/SCTP/public/Message.cpp',
 ]
 
@@ -294,14 +306,6 @@ libsrtp3_proj = subproject(
   ],
 )
 
-usrsctp_proj = subproject(
-  'usrsctp',
-  default_options: [
-    'warning_level=0',
-    'sctp_build_programs=false',
-  ],
-)
-
 abseil_cpp_proj = subproject(
   'abseil-cpp',
   default_options: [
@@ -329,7 +333,6 @@ dependencies = [
   openssl_proj.get_variable('openssl_dep'),
   libuv_proj.get_variable('libuv_dep'),
   libsrtp3_proj.get_variable('libsrtp3_dep'),
-  usrsctp_proj.get_variable('usrsctp_dep'),
   flatbuffers_proj.get_variable('flatbuffers_dep'),
   flatbuffers_generator_dep,
   libwebrtc_dep,
@@ -341,7 +344,6 @@ link_whole = [
   openssl_proj.get_variable('libssl_lib'),
   libuv_proj.get_variable('libuv'),
   libsrtp3_proj.get_variable('libsrtp3'),
-  usrsctp_proj.get_variable('usrsctp'),
   flatbuffers_proj.get_variable('flatbuffers_lib'),
   libwebrtc,
 ]
@@ -433,6 +435,13 @@ executable(
   cpp_args: cpp_args + ['-DMS_EXECUTABLE'],
 )
 
+mock_sources = [
+  'mocks/src/MockShared.cpp',
+  'mocks/src/handles/MockBackoffTimerHandle.cpp',
+  'mocks/src/Channel/MockChannelMessageRegistrator.cpp',
+  'mocks/src/RTC/SCTP/association/MockTransmissionControlBlockContext.cpp',
+]
+
 test_sources = [
   'test/src/tests.cpp',
   'test/src/testHelpers.cpp',
@@ -480,11 +489,21 @@ test_sources = [
   'test/src/RTC/RTCP/TestPacket.cpp',
   'test/src/RTC/RTCP/TestXr.cpp',
   'test/src/RTC/SCTP/sctpCommon.cpp',
-  'test/src/RTC/SCTP/association/TestStateCookie.cpp',
+  'test/src/RTC/SCTP/association/TestHeartbeatHandler.cpp',
   'test/src/RTC/SCTP/association/TestNegotiatedCapabilities.cpp',
-  'test/src/RTC/SCTP/common/TestUnwrappedSequenceNumber.cpp',
+  'test/src/RTC/SCTP/association/TestStateCookie.cpp',
+  'test/src/RTC/SCTP/association/TestTransmissionControlBlock.cpp',
+  'test/src/RTC/SCTP/rx/TestDataTracker.cpp',
+  'test/src/RTC/SCTP/rx/TestInterleavedReassemblyStreams.cpp',
+  'test/src/RTC/SCTP/rx/TestReassemblyQueue.cpp',
+  'test/src/RTC/SCTP/rx/TestTraditionalReassemblyStreams.cpp',
+  'test/src/RTC/SCTP/tx/TestOutstandingData.cpp',
   'test/src/RTC/SCTP/tx/TestRetransmissionErrorCounter.cpp',
+  'test/src/RTC/SCTP/tx/TestRetransmissionQueue.cpp',
   'test/src/RTC/SCTP/tx/TestRetransmissionTimeout.cpp',
+  'test/src/RTC/SCTP/tx/TestRoundRobinSendQueue.cpp',
+  'test/src/RTC/SCTP/tx/TestOutstandingData.cpp',
+  'test/src/RTC/SCTP/tx/TestStreamScheduler.cpp',
   'test/src/RTC/SCTP/packet/TestPacket.cpp',
   'test/src/RTC/SCTP/packet/TestChunk.cpp',
   'test/src/RTC/SCTP/packet/TestParameter.cpp',
@@ -545,6 +564,7 @@ test_sources = [
   'test/src/Utils/TestNumber.cpp',
   'test/src/Utils/TestString.cpp',
   'test/src/Utils/TestTime.cpp',
+  'test/src/Utils/TestUnwrappedSequenceNumber.cpp',
 ]
 
 mediasoup_worker_test = executable(
@@ -553,10 +573,9 @@ mediasoup_worker_test = executable(
   install: true,
   install_tag: 'mediasoup-worker-test',
   dependencies: dependencies,
-  sources: common_sources + test_sources,
+  sources: common_sources + test_sources + mock_sources,
   include_directories: include_directories(
     'include',
-    'test/include',
   ),
   cpp_args: cpp_args,
 )
@@ -573,10 +592,9 @@ mediasoup_worker_test_asan_address = executable(
   install: true,
   install_tag: 'mediasoup-worker-test-asan-address',
   dependencies: dependencies,
-  sources: common_sources + test_sources,
+  sources: common_sources + test_sources + mock_sources,
   include_directories: include_directories(
     'include',
-    'test/include',
   ),
   cpp_args: cpp_args + [
     '-g',
@@ -601,10 +619,9 @@ mediasoup_worker_test_asan_undefined = executable(
   install: true,
   install_tag: 'mediasoup-worker-test-asan-undefined',
   dependencies: dependencies,
-  sources: common_sources + test_sources,
+  sources: common_sources + test_sources + mock_sources,
   include_directories: include_directories(
     'include',
-    'test/include',
   ),
   cpp_args: cpp_args + [
     '-g',
@@ -623,7 +640,7 @@ test(
   workdir: meson.project_source_root(),
 )
 
-fuzzer_sources = common_sources + [
+fuzzer_sources = [
   'fuzzer/src/fuzzer.cpp',
   'fuzzer/src/FuzzerUtils.cpp',
   'fuzzer/src/RTC/FuzzerDtlsTransport.cpp',
@@ -665,7 +682,7 @@ fuzzer_sources = common_sources + [
   'fuzzer/src/RTC/RTCP/FuzzerSenderReport.cpp',
   'fuzzer/src/RTC/RTCP/FuzzerXr.cpp',
   'fuzzer/src/RTC/SCTP/association/FuzzerStateCookie.cpp',
-  'fuzzer/src/RTC/SCTP/packet/FuzzerPacket.cpp'
+  'fuzzer/src/RTC/SCTP/packet/FuzzerPacket.cpp',
 ]
 
 executable(
@@ -674,13 +691,12 @@ executable(
   install: true,
   install_tag: 'mediasoup-worker-fuzzer',
   dependencies: dependencies,
-  sources: fuzzer_sources,
+  sources: common_sources + fuzzer_sources + mock_sources,
   include_directories: include_directories(
     'include',
-    'fuzzer/include',
+    'fuzzer/include'
   ),
   cpp_args: cpp_args + [
-    '-DMS_LOG_STD',
     '-g',
     '-O3',
     '-fno-omit-frame-pointer',

package/worker/meson_options.txt

@@ -1,7 +1,8 @@
-option('ms_build_tests', type: 'boolean', value: false, description: 'Whether to build mediasoup worker tests')
 option('ms_log_trace', type: 'boolean', value: false, description: 'Logs the current method/function if current log level is "debug"')
 option('ms_log_file_line', type: 'boolean', value: false, description: 'Logging macros print more verbose information, including current file and line')
 option('ms_rtc_logger_rtp', type: 'boolean', value: false, description: 'Prints a line with information for each processed RTP packet')
 option('ms_dump_rtp_payload_descriptor', type: 'boolean', value: false, description: 'RTC::RTP::Packet::Dump() method also dumps payload descriptor details')
 option('ms_dump_rtp_shared_packet_memory_usage', type: 'boolean', value: false, description: 'prints information about total memory allocated by RTC::RTP::SharedPacket instances')
 option('ms_disable_liburing', type: 'boolean', value: false, description: 'When set to true, disables liburing integration despite current host supports it')
+option('ms_build_tests', type: 'boolean', value: false, description: 'Must be enabled when building mediasoup worker tests')
+option('ms_build_fuzzer', type: 'boolean', value: false, description: 'Must be enabled when building mediasoup worker fuzzer')

package/worker/mocks/include/Channel/MockChannelMessageRegistrator.hpp

@@ -0,0 +1,45 @@
+#ifndef MS_MOCKS_MOCK_CHANNEL_MESSAGE_REGISTRATOR_HPP
+#define MS_MOCKS_MOCK_CHANNEL_MESSAGE_REGISTRATOR_HPP
+
+#include "Channel/ChannelMessageRegistratorInterface.hpp"
+// TODO: We should have a ChannelSocketInterface class instead.
+#include "Channel/ChannelSocket.hpp"
+#include <string>
+#include <unordered_map>
+
+namespace mocks
+{
+	namespace Channel
+	{
+		class MockChannelMessageRegistrator : public ::Channel::ChannelMessageRegistratorInterface
+		{
+		public:
+			explicit MockChannelMessageRegistrator();
+
+			~MockChannelMessageRegistrator() override;
+
+		public:
+			flatbuffers::Offset<FBS::Worker::ChannelMessageHandlers> FillBuffer(
+			  flatbuffers::FlatBufferBuilder& builder) override;
+
+			void RegisterHandler(
+			  const std::string& id,
+			  ::Channel::ChannelSocket::RequestHandler* channelRequestHandler,
+			  ::Channel::ChannelSocket::NotificationHandler* channelNotificationHandler) override;
+
+			void UnregisterHandler(const std::string& id) override;
+
+			::Channel::ChannelSocket::RequestHandler* GetChannelRequestHandler(const std::string& id) override;
+
+			::Channel::ChannelSocket::NotificationHandler* GetChannelNotificationHandler(
+			  const std::string& id) override;
+
+		private:
+			std::unordered_map<std::string, ::Channel::ChannelSocket::RequestHandler*> mapChannelRequestHandlers;
+			std::unordered_map<std::string, ::Channel::ChannelSocket::NotificationHandler*>
+			  mapChannelNotificationHandlers;
+		};
+	} // namespace Channel
+} // namespace mocks
+
+#endif

package/worker/mocks/include/MockShared.hpp

@@ -0,0 +1,90 @@
+#ifndef MS_MOCKS_MOCK_SHARED_HPP
+#define MS_MOCKS_MOCK_SHARED_HPP
+
+#include "Channel/ChannelNotifier.hpp"
+#include "Channel/ChannelSocket.hpp"
+#include "SharedInterface.hpp"
+#include "mocks/include/Channel/MockChannelMessageRegistrator.hpp"
+#include "mocks/include/handles/MockBackoffTimerHandle.hpp"
+#include <map>
+#include <string>
+#include <string_view>
+
+namespace mocks
+{
+	class MockShared : public SharedInterface
+	{
+	public:
+		explicit MockShared(std::function<uint64_t()> getTimeMs);
+
+		~MockShared() override = default;
+
+	public:
+		::Channel::ChannelMessageRegistratorInterface* GetChannelMessageRegistrator() override
+		{
+			return this->channelMessageRegistrator.get();
+		}
+
+		::Channel::ChannelNotifier* GetChannelNotifier() override
+		{
+			return this->channelNotifier.get();
+		}
+
+		TimerHandleInterface* CreateTimer(TimerHandleInterface::Listener* listener) override;
+
+		BackoffTimerHandleInterface* CreateBackoffTimer(
+		  const BackoffTimerHandleInterface::BackoffTimerHandleOptions& options) override;
+
+		uint64_t GetTimeMs() override
+		{
+			return this->getTimeMs();
+		}
+
+		uint64_t GetTimeUs() override
+		{
+			return GetTimeMs() * 1000;
+		}
+
+		uint64_t GetTimeNs() override
+		{
+			return GetTimeMs() * 1000 * 1000;
+		}
+
+		int64_t GetTimeMsInt64() override
+		{
+			return static_cast<int64_t>(GetTimeMs());
+		}
+
+		int64_t GetTimeUsInt64() override
+		{
+			return static_cast<int64_t>(GetTimeUs());
+		}
+
+		// Methods for testing.
+	public:
+		MockBackoffTimerHandle* GetBackoffTimer(const std::string_view label) const
+		{
+			const auto it = this->backoffTimers.find(std::string(label));
+
+			if (it != this->backoffTimers.end())
+			{
+				return it->second;
+			}
+			else
+			{
+				return nullptr;
+			}
+		}
+
+	private:
+		// Given by argument.
+		const std::function<uint64_t()> getTimeMs;
+		// Others.
+		std::unique_ptr<::Channel::ChannelSocket> channelSocket;
+		std::unique_ptr<mocks::Channel::MockChannelMessageRegistrator> channelMessageRegistrator;
+		std::unique_ptr<::Channel::ChannelNotifier> channelNotifier;
+		std::map<std::string /*label*/, MockBackoffTimerHandle* /*backoffTimer*/> backoffTimers;
+	};
+} // namespace mocks
+
+#endif

package/worker/mocks/include/RTC/SCTP/association/MockAssociationListener.hpp

@@ -0,0 +1,308 @@
+#ifndef MS_MOCKS_RTC_SCTP_MOCK_ASSOCIATION_LISTENER_HPP
+#define MS_MOCKS_RTC_SCTP_MOCK_ASSOCIATION_LISTENER_HPP
+
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
+#include <deque>
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+namespace mocks
+{
+	namespace RTC
+	{
+		namespace SCTP
+		{
+			class MockAssociationListener : public ::RTC::SCTP::AssociationListenerInterface
+			{
+			public:
+				bool OnAssociationSendData(const uint8_t* data, size_t len) override
+				{
+					this->sentPackets.emplace_back(data, data + len);
+
+					return true;
+				}
+
+				void OnAssociationConnecting() override
+				{
+					this->connecting = true;
+				}
+
+				void OnAssociationConnected() override
+				{
+					this->connecting = false;
+					this->connected  = true;
+				}
+
+				void OnAssociationFailed(
+				  ::RTC::SCTP::Types::ErrorKind errorKind, std::string_view errorMessage) override
+				{
+					this->connecting         = false;
+					this->connected          = false;
+					this->failed             = true;
+					this->failedErrorKind    = errorKind;
+					this->failedErrorMessage = errorMessage;
+				}
+
+				void OnAssociationClosed(
+				  ::RTC::SCTP::Types::ErrorKind errorKind, std::string_view errorMessage) override
+				{
+					this->connecting         = false;
+					this->connected          = false;
+					this->closed             = true;
+					this->closedErrorKind    = errorKind;
+					this->closedErrorMessage = errorMessage;
+				}
+
+				void OnAssociationRestarted() override
+				{
+					this->restarted = true;
+				}
+
+				void OnAssociationError(
+				  ::RTC::SCTP::Types::ErrorKind errorKind, std::string_view errorMessage) override
+				{
+					this->connecting          = false;
+					this->connected           = false;
+					this->errored             = true;
+					this->erroredErrorKind    = errorKind;
+					this->erroredErrorMessage = errorMessage;
+				}
+
+				void OnAssociationMessageReceived(::RTC::SCTP::Message message) override
+				{
+					this->receivedMessages.emplace_back(std::move(message));
+				}
+
+				void OnAssociationStreamsResetPerformed(std::span<const uint16_t> /*outboundStreamIds*/) override
+				{
+					// TODO: Do something here for tests.
+				}
+
+				void OnAssociationStreamsResetFailed(
+				  std::span<const uint16_t> /*outboundStreamIds*/, std::string_view /*errorMessage*/) override
+				{
+					// TODO: Do something here for tests.
+				}
+
+				void OnAssociationInboundStreamsReset(std::span<const uint16_t> /*inboundStreamIds*/) override
+				{
+					// TODO: Do something here for tests.
+				}
+
+				void OnAssociationStreamBufferedAmountLow(uint16_t streamId) override
+				{
+					++this->onStreamBufferedAmountLowCalls[streamId];
+				}
+
+				void OnAssociationTotalBufferedAmountLow() override
+				{
+					++this->onTotalBufferedAmountLowCalls;
+				}
+
+				bool OnAssociationIsTransportReadyForSctp() override
+				{
+					return this->transportReady;
+				}
+
+				void OnAssociationLifecycleMessageFullySent(uint64_t lifecycleId) override
+				{
+					this->onAssociationLifecycleMessageFullySentCalls.insert(lifecycleId);
+				}
+
+				void OnAssociationLifecycleMessageExpired(uint64_t lifecycleId, bool maybeDelivered) override
+				{
+					this->onAssociationLifecycleMessageExpiredCalls[lifecycleId] = maybeDelivered;
+				}
+
+				void OnAssociationLifecycleMessageDelivered(uint64_t lifecycleId) override
+				{
+					this->onAssociationLifecycleMessageDeliveredCalls.insert(lifecycleId);
+				}
+
+				void OnAssociationLifecycleMessageEnd(uint64_t lifecycleId) override
+				{
+					this->onAssociationLifecycleMessageEndCalls.insert(lifecycleId);
+				}
+
+				// Methods for testing.
+			public:
+				bool IsConnecting() const
+				{
+					return this->connecting;
+				}
+
+				bool IsConnected() const
+				{
+					return this->connected;
+				}
+
+				bool HasRestarted() const
+				{
+					return this->restarted;
+				}
+
+				bool HasFailed() const
+				{
+					return this->failed;
+				}
+
+				::RTC::SCTP::Types::ErrorKind GetFailedErrorKind() const
+				{
+					return this->failedErrorKind;
+				}
+
+				const std::string& GetFailedErrorMessage() const
+				{
+					return this->failedErrorMessage;
+				}
+
+				bool IsClosed() const
+				{
+					return this->closed;
+				}
+
+				::RTC::SCTP::Types::ErrorKind GetClosedErrorKind() const
+				{
+					return this->closedErrorKind;
+				}
+
+				const std::string& GetClosedErrorMessage() const
+				{
+					return this->closedErrorMessage;
+				}
+
+				bool HasErrored() const
+				{
+					return this->errored;
+				}
+
+				::RTC::SCTP::Types::ErrorKind GetErroredErrorKind() const
+				{
+					return this->erroredErrorKind;
+				}
+
+				const std::string& GetErroredErrorMessage() const
+				{
+					return this->erroredErrorMessage;
+				}
+
+				bool HasOnStreamBufferedAmountLowBeenCalledWithStreamId(uint64_t streamId) const
+				{
+					return this->onStreamBufferedAmountLowCalls.contains(streamId);
+				}
+
+				size_t CountOnStreamBufferedAmountLowCallsWithStreamId(uint64_t streamId) const
+				{
+					if (!this->onStreamBufferedAmountLowCalls.contains(streamId))
+					{
+						return 0;
+					}
+
+					return this->onStreamBufferedAmountLowCalls.at(streamId);
+				}
+
+				size_t CountOnTotalBufferedAmountLowCalls() const
+				{
+					return this->onTotalBufferedAmountLowCalls;
+				}
+
+				bool HasSentPackets() const
+				{
+					return !this->sentPackets.empty();
+				}
+
+				bool HasReceivedMessages() const
+				{
+					return !this->receivedMessages.empty();
+				}
+
+				std::vector<uint8_t> ConsumeFirstSentPacket()
+				{
+					if (this->sentPackets.empty())
+					{
+						return {};
+					}
+
+					const auto packet = std::move(this->sentPackets.front());
+
+					this->sentPackets.pop_front();
+
+					return packet;
+				}
+
+				std::optional<::RTC::SCTP::Message> ConsumeFirstReceivedMessage()
+				{
+					if (this->receivedMessages.empty())
+					{
+						return std::nullopt;
+					}
+
+					auto message = std::move(this->receivedMessages.front());
+
+					this->receivedMessages.pop_front();
+
+					return message;
+				}
+
+				bool IsTransportReady() const
+				{
+					return this->transportReady;
+				}
+
+				bool HasOnAssociationLifecycleMessageFullySentBeenCalledWithLifecycleId(uint64_t lifecycleId) const
+				{
+					return this->onAssociationLifecycleMessageFullySentCalls.contains(lifecycleId);
+				}
+
+				bool HasOnAssociationLifecycleMessageExpiredSentBeenCalledWithLifecycleId(
+				  uint64_t lifecycleId, bool maybeDelivered) const
+				{
+					if (!this->onAssociationLifecycleMessageExpiredCalls.contains(lifecycleId))
+					{
+						return false;
+					}
+
+					return this->onAssociationLifecycleMessageExpiredCalls.at(lifecycleId) == maybeDelivered;
+				}
+
+				bool HasOnAssociationLifecycleMessageDeliveredBeenCalledWithLifecycleId(uint64_t lifecycleId) const
+				{
+					return this->onAssociationLifecycleMessageDeliveredCalls.contains(lifecycleId);
+				}
+
+				bool HasOnAssociationLifecycleMessageEndBeenCalledWithLifecycleId(uint64_t lifecycleId) const
+				{
+					return this->onAssociationLifecycleMessageEndCalls.contains(lifecycleId);
+				}
+
+			private:
+				// Observable state for tests.
+				bool connecting{ false };
+				bool connected{ false };
+				bool restarted{ false };
+				bool failed{ false };
+				::RTC::SCTP::Types::ErrorKind failedErrorKind;
+				std::string failedErrorMessage;
+				bool closed{ false };
+				::RTC::SCTP::Types::ErrorKind closedErrorKind;
+				std::string closedErrorMessage;
+				bool errored{ false };
+				::RTC::SCTP::Types::ErrorKind erroredErrorKind;
+				std::string erroredErrorMessage;
+				std::map<uint16_t /*streamId*/, size_t /*count*/> onStreamBufferedAmountLowCalls;
+				size_t onTotalBufferedAmountLowCalls{ 0 };
+				std::deque<std::vector<uint8_t>> sentPackets;
+				std::deque<::RTC::SCTP::Message> receivedMessages;
+				bool transportReady{ true };
+				std::set<uint64_t /*lifecycleId*/> onAssociationLifecycleMessageFullySentCalls;
+				std::map<uint64_t /*lifecycleId*/, bool /*maybeDelivered*/> onAssociationLifecycleMessageExpiredCalls;
+				std::set<uint64_t /*lifecycleId*/> onAssociationLifecycleMessageDeliveredCalls;
+				std::set<uint64_t /*lifecycleId*/> onAssociationLifecycleMessageEndCalls;
+			};
+		} // namespace SCTP
+	} // namespace RTC
+} // namespace mocks
+
+#endif