mediasoup 3.19.21 → 3.20.0

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

@@ -0,0 +1,183 @@
+#ifndef MS_MOCKS_RTC_SCTP_MOCK_TRANSMISSION_CONTROL_BLOCK_HPP
+#define MS_MOCKS_RTC_SCTP_MOCK_TRANSMISSION_CONTROL_BLOCK_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/association/TransmissionControlBlockContextInterface.hpp"
+#include "RTC/SCTP/packet/Packet.hpp"
+#include "RTC/SCTP/public/AssociationListenerInterface.hpp"
+#include "RTC/SCTP/public/SctpOptions.hpp"
+#include "mocks/include/mockTypes.hpp"
+#include <queue>
+#include <stdexcept>
+#include <string>
+
+namespace mocks
+{
+	namespace RTC
+	{
+		namespace SCTP
+		{
+			class MockTransmissionControlBlockContext
+			  : public ::RTC::SCTP::TransmissionControlBlockContextInterface
+			{
+			public:
+				using GetCurrentRtoMsAction = std::function<uint64_t()>;
+
+			public:
+				explicit MockTransmissionControlBlockContext(
+				  ::RTC::SCTP::AssociationListenerInterface& associationListener,
+				  const ::RTC::SCTP::SctpOptions& sctpOptions)
+				  : associationListener(associationListener), sctpOptions(sctpOptions)
+				{
+				}
+
+			public:
+				bool IsAssociationEstablished() const override
+				{
+					return this->associationEstablished;
+				}
+
+				uint32_t GetLocalInitialTsn() const override
+				{
+					// TODO: Implement this.
+					return 0;
+				}
+
+				uint32_t GetRemoteInitialTsn() const override
+				{
+					// TODO: Implement this.
+					return 0;
+				}
+
+				void ObserveRttMs(uint64_t rttMs) override
+				{
+					this->observeRttMsCallCount++;
+				}
+
+				uint64_t GetCurrentRtoMs() const override
+				{
+					if (!this->getCurrentRtoMsOnceActions.empty())
+					{
+						auto action = std::move(this->getCurrentRtoMsOnceActions.front());
+
+						this->getCurrentRtoMsOnceActions.pop();
+
+						return action();
+					}
+					else
+					{
+						return 0;
+					}
+				}
+
+				bool IncrementTxErrorCounter(std::string_view /*reason*/) override
+				{
+					this->incrementTxErrorCounterCallCount++;
+
+					return false;
+				}
+
+				void ClearTxErrorCounter() override
+				{
+					this->incrementTxErrorCounterCallCount = 0;
+				}
+
+				bool HasTooManyTxErrors() const override
+				{
+					// TODO: Implement this.
+					return false;
+				}
+
+				std::unique_ptr<::RTC::SCTP::Packet> CreatePacket() const override;
+
+				bool SendPacket(::RTC::SCTP::Packet* packet) override;
+
+				// Methods for testing.
+			public:
+				void SetAssociationEstablished(bool associationEstablished)
+				{
+					this->associationEstablished = associationEstablished;
+				}
+
+				/**
+				 * @remarks
+				 * - Must be called before expecting calls to `ObserveRttMs()`.
+				 */
+				MockTransmissionControlBlockContext& ExpectObserveRttMsCalledTimes(size_t times)
+				{
+					this->observeRttMsCallCount         = 0;
+					this->expectedObserveRttMsCallCount = times;
+
+					return *this;
+				}
+
+				/**
+				 * @remarks
+				 * - Must be called before expecting calls to `IncrementTxErrorCounter()`.
+				 */
+				MockTransmissionControlBlockContext& ExpectIncrementTxErrorCounterCalledTimes(size_t times)
+				{
+					this->incrementTxErrorCounterCallCount         = 0;
+					this->expectedIncrementTxErrorCounterCallCount = times;
+
+					return *this;
+				}
+
+				MockTransmissionControlBlockContext& WillGetCurrentRtoMsOnce(GetCurrentRtoMsAction action)
+				{
+					this->getCurrentRtoMsOnceActions.push(std::move(action));
+
+					return *this;
+				}
+
+				mocks::VerificationResult VerifyExpectations() const
+				{
+					if (
+					  this->expectedObserveRttMsCallCount.has_value() &&
+					  this->observeRttMsCallCount != this->expectedObserveRttMsCallCount.value())
+					{
+						return { .ok           = false,
+							       .errorMessage = "ObserveRttMs() call count mismatch [expected:" +
+							                       std::to_string(this->expectedObserveRttMsCallCount.value()) +
+							                       ", got:" + std::to_string(this->observeRttMsCallCount) + "]" };
+					}
+
+					if (
+					  this->expectedIncrementTxErrorCounterCallCount.has_value() &&
+					  this->incrementTxErrorCounterCallCount !=
+					    this->expectedIncrementTxErrorCounterCallCount.value())
+					{
+						return { .ok = false,
+							       .errorMessage =
+							         "IncrementTxErrorCounter() call count mismatch [expected:" +
+							         std::to_string(this->expectedIncrementTxErrorCounterCallCount.value()) +
+							         ", got:" + std::to_string(this->incrementTxErrorCounterCallCount) + "]" };
+					}
+
+					return { .ok = true, .errorMessage = "" };
+				}
+
+			private:
+				// Passed by argument.
+				::RTC::SCTP::AssociationListenerInterface& associationListener;
+				const ::RTC::SCTP::SctpOptions sctpOptions;
+
+				// ObserveRttMs().
+				size_t observeRttMsCallCount{ 0 };
+				std::optional<size_t> expectedObserveRttMsCallCount;
+
+				// GetCurrentRtoMs().
+				mutable std::queue<GetCurrentRtoMsAction> getCurrentRtoMsOnceActions;
+
+				// IncrementTxErrorCounter().
+				size_t incrementTxErrorCounterCallCount{ 0 };
+				std::optional<size_t> expectedIncrementTxErrorCounterCallCount;
+
+				// Others.
+				bool associationEstablished{ false };
+			};
+		} // namespace SCTP
+	} // namespace RTC
+} // namespace mocks
+
+#endif

package/worker/mocks/include/RTC/SCTP/tx/MockSendQueue.hpp

@@ -0,0 +1,262 @@
+#ifndef MS_MOCKS_RTC_SCTP_MOCK_SEND_QUEUE_HPP
+#define MS_MOCKS_RTC_SCTP_MOCK_SEND_QUEUE_HPP
+
+#include "common.hpp"
+#include "RTC/SCTP/tx/SendQueueInterface.hpp"
+#include "mocks/include/mockTypes.hpp"
+#include <queue>
+#include <stdexcept>
+#include <string>
+
+namespace mocks
+{
+	namespace RTC
+	{
+		namespace SCTP
+		{
+			class MockSendQueue : public ::RTC::SCTP::SendQueueInterface
+			{
+			public:
+				using ProduceAction =
+				  std::function<std::optional<DataToSend>(uint64_t /*nowMs*/, size_t /*maxLength*/)>;
+
+				struct DiscardExpectation
+				{
+					// If std::nullopt, don't check it.
+					std::optional<uint16_t> streamId;
+					// If std::nullopt, don't check it.
+					std::optional<uint32_t> outgoingMessageId;
+					bool returnValue{ false };
+				};
+
+			public:
+				MockSendQueue() = default;
+
+				~MockSendQueue() override = default;
+
+			public:
+				void EnableMessageInterleaving(bool enabled) override
+				{
+					this->messageInterleavingCalledWith = enabled;
+				}
+
+				std::optional<DataToSend> Produce(uint64_t nowMs, size_t maxLength) override
+				{
+					this->produceCallCount++;
+
+					if (!this->produceOnceActions.empty())
+					{
+						auto action = std::move(this->produceOnceActions.front());
+
+						this->produceOnceActions.pop();
+
+						return action(nowMs, maxLength);
+					}
+					else if (this->produceRepeatedlyAction)
+					{
+						return this->produceRepeatedlyAction(nowMs, maxLength);
+					}
+					else
+					{
+						return std::nullopt;
+					}
+				}
+
+				bool Discard(uint16_t streamId, uint32_t outgoingMessageId) override
+				{
+					this->discardCallCount++;
+
+					if (this->discardExpectations.empty())
+					{
+						throw std::logic_error("Discard() called but no expectation was set");
+					}
+
+					auto discardExpectation = this->discardExpectations.front();
+
+					this->discardExpectations.pop();
+
+					if (discardExpectation.streamId.has_value() && discardExpectation.streamId.value() != streamId)
+					{
+						throw std::logic_error(
+						  "Discard() called with unexpected streamId [expected:" +
+						  std::to_string(discardExpectation.streamId.value()) +
+						  ", got:" + std::to_string(streamId) + "]");
+					}
+
+					if (
+					  discardExpectation.outgoingMessageId.has_value() &&
+					  discardExpectation.outgoingMessageId.value() != outgoingMessageId)
+					{
+						throw std::logic_error(
+						  "Discard() called with unexpected outgoingMessageId [expected:" +
+						  std::to_string(discardExpectation.outgoingMessageId.value()) +
+						  ", got:" + std::to_string(outgoingMessageId) + "]");
+					}
+
+					return discardExpectation.returnValue;
+				}
+
+				void PrepareResetStream(uint16_t /*streamId*/) override
+				{
+				}
+
+				bool HasStreamsReadyToBeReset() const override
+				{
+					return false;
+				}
+
+				std::vector<uint16_t> GetStreamsReadyToBeReset() override
+				{
+					return {};
+				}
+
+				void CommitResetStreams() override
+				{
+				}
+
+				void RollbackResetStreams() override
+				{
+				}
+
+				void Reset() override
+				{
+				}
+
+				size_t GetStreamBufferedAmount(uint16_t /*streamId*/) const override
+				{
+					return 0;
+				}
+
+				size_t GetTotalBufferedAmount() const override
+				{
+					return 0;
+				}
+
+				size_t GetStreamBufferedAmountLowThreshold(uint16_t /*streamId*/) const override
+				{
+					return 0;
+				}
+
+				void SetStreamBufferedAmountLowThreshold(uint16_t /*streamId*/, size_t /*bytes*/) override
+				{
+				}
+
+				// Methods for testing.
+			public:
+				MockSendQueue& ExpectEnableMessageInterleavingCalledWith(bool enabled)
+				{
+					this->expectedMessageInterleavingCalledWith = enabled;
+
+					return *this;
+				}
+
+				MockSendQueue& WillProduceOnce(ProduceAction action)
+				{
+					this->produceOnceActions.push(std::move(action));
+
+					return *this;
+				}
+
+				MockSendQueue& WillProduceRepeatedly(ProduceAction action)
+				{
+					this->produceRepeatedlyAction = std::move(action);
+
+					return *this;
+				}
+
+				/**
+				 * @remarks
+				 * - Must be called before expecting calls to `Produce()`.
+				 */
+				MockSendQueue& ExpectProduceCalledTimes(size_t times)
+				{
+					this->produceCallCount         = 0;
+					this->expectedProduceCallCount = times;
+
+					return *this;
+				}
+
+				MockSendQueue& WillDiscardOnce(uint16_t streamId, uint32_t outgoingMessageId, bool returnValue)
+				{
+					this->discardExpectations.push({ streamId, outgoingMessageId, returnValue });
+
+					return *this;
+				}
+
+				/**
+				 * @remarks
+				 * - Must be called before expecting calls to `Discard()`.
+				 */
+				MockSendQueue& ExpectDiscardCalledTimes(size_t times)
+				{
+					this->discardCallCount         = 0;
+					this->expectedDiscardCallCount = times;
+
+					return *this;
+				}
+
+				mocks::VerificationResult VerifyExpectations() const
+				{
+					if (
+					  this->expectedMessageInterleavingCalledWith.has_value() &&
+					  this->messageInterleavingCalledWith != this->expectedMessageInterleavingCalledWith.value())
+					{
+						return { .ok = false,
+							       .errorMessage =
+							         std::string("EnableMessageInterleaving() call mismatch [expected:") +
+							         (this->expectedMessageInterleavingCalledWith.value() ? "true" : "false") +
+							         ", got:" + (this->messageInterleavingCalledWith ? "true" : "false") + "]" };
+					}
+
+					if (
+					  this->expectedProduceCallCount.has_value() &&
+					  this->produceCallCount != this->expectedProduceCallCount.value())
+					{
+						return { .ok           = false,
+							       .errorMessage = "Produce() call count mismatch [expected:" +
+							                       std::to_string(this->expectedProduceCallCount.value()) +
+							                       ", got:" + std::to_string(this->produceCallCount) + "]" };
+					}
+
+					if (
+					  this->expectedDiscardCallCount.has_value() &&
+					  this->discardCallCount != this->expectedDiscardCallCount.value())
+					{
+						return { .ok           = false,
+							       .errorMessage = "Discard() call count mismatch [expected:" +
+							                       std::to_string(this->expectedDiscardCallCount.value()) +
+							                       ", got:" + std::to_string(this->discardCallCount) + "]" };
+					}
+
+					if (!this->discardExpectations.empty())
+					{
+						return { .ok           = false,
+							       .errorMessage = "Discard() has " +
+							                       std::to_string(this->discardExpectations.size()) +
+							                       " unconsumed expectation(s)" };
+					}
+
+					return { .ok = true, .errorMessage = "" };
+				}
+
+			private:
+				// EnableMessageInterleaving().
+				bool messageInterleavingCalledWith{ false };
+				std::optional<bool> expectedMessageInterleavingCalledWith;
+
+				// Produce().
+				std::queue<ProduceAction> produceOnceActions;
+				ProduceAction produceRepeatedlyAction;
+				size_t produceCallCount{ 0 };
+				std::optional<size_t> expectedProduceCallCount;
+
+				// Discard().
+				std::queue<DiscardExpectation> discardExpectations;
+				size_t discardCallCount{ 0 };
+				std::optional<size_t> expectedDiscardCallCount;
+			};
+		} // namespace SCTP
+	} // namespace RTC
+} // namespace mocks
+
+#endif

package/worker/mocks/include/handles/MockBackoffTimerHandle.hpp

@@ -0,0 +1,153 @@
+#ifndef MS_MOCKS_MOCK_BACKOFF_TIMER_HANDLE_HPP
+#define MS_MOCKS_MOCK_BACKOFF_TIMER_HANDLE_HPP
+
+#include "common.hpp"
+#include "handles/BackoffTimerHandleInterface.hpp"
+#include <limits>
+
+namespace mocks
+{
+	// Forward declaration.
+	class MockShared;
+
+	class MockBackoffTimerHandle : public BackoffTimerHandleInterface
+	{
+		// Only MockShared class can invoke the constructor.
+		friend class mocks::MockShared;
+
+	private:
+		explicit MockBackoffTimerHandle(
+		  BackoffTimerHandleOptions options,
+		  std::function<uint64_t()> getTimeMs,
+		  std::function<void()> onDelete);
+
+	public:
+		MockBackoffTimerHandle& operator=(const MockBackoffTimerHandle&) = delete;
+
+		MockBackoffTimerHandle(const MockBackoffTimerHandle&) = delete;
+
+		~MockBackoffTimerHandle() override
+		{
+			this->onDelete();
+		}
+
+	public:
+		void Dump(int indentation = 0) const;
+
+		void Start() override
+		{
+			this->running     = true;
+			this->expiresAtMs = this->getTimeMs() + ComputeNextTimeoutMs();
+		}
+
+		void Stop() override
+		{
+			this->running     = false;
+			this->expiresAtMs = std::numeric_limits<uint64_t>::max();
+		}
+
+		/**
+		 * @remarks
+		 * - This method must be defined in the .cpp since it's called by the
+		 *   constructor. Otherwise clang-tidy complains:
+		 *   "warning: Call to virtual method 'BackoffTimerHandle::SetBaseTimeoutMs'
+		 *   during construction bypasses virtual dispatch
+		 *   [clang-analyzer-optin.cplusplus.VirtualCall]"
+		 */
+		void SetBaseTimeoutMs(uint64_t baseTimeoutMs) override;
+
+		bool IsRunning() const override
+		{
+			return this->running;
+		}
+
+		const std::string GetLabel() const override
+		{
+			return this->label;
+		}
+
+		std::optional<size_t> GetMaxRestarts() const override
+		{
+			return this->maxRestarts;
+		}
+
+		size_t GetExpirationCount() const override
+		{
+			return this->expirationCount;
+		}
+
+		// Methods for testing.
+	public:
+		uint64_t GetExpiresAtMs() const
+		{
+			return this->expiresAtMs;
+		}
+
+		bool EvaluateHasExpired()
+		{
+			if (this->getTimeMs() >= this->expiresAtMs)
+			{
+				TriggerExpire();
+
+				return true;
+			}
+			else
+			{
+				return false;
+			}
+		}
+
+	private:
+		uint64_t ComputeNextTimeoutMs() const
+		{
+			auto expirationCount = this->expirationCount;
+
+			switch (this->backoffAlgorithm)
+			{
+				case BackoffAlgorithm::FIXED:
+				{
+					return this->baseTimeoutMs;
+				}
+
+				case BackoffAlgorithm::EXPONENTIAL:
+				{
+					auto timeoutMs = this->baseTimeoutMs;
+
+					while (expirationCount > 0 && timeoutMs < BackoffTimerHandleInterface::MaxTimeoutMs)
+					{
+						timeoutMs *= 2;
+						--expirationCount;
+
+						if (this->maxBackoffTimeoutMs.has_value() && timeoutMs > this->maxBackoffTimeoutMs.value())
+						{
+							return this->maxBackoffTimeoutMs.value();
+						}
+					}
+
+					return std::min<uint64_t>(timeoutMs, BackoffTimerHandleInterface::MaxTimeoutMs);
+				}
+
+					NO_DEFAULT_GCC();
+			}
+		}
+
+		void TriggerExpire();
+
+	private:
+		// Passed by argument.
+		BackoffTimerHandleInterface::Listener* listener{ nullptr };
+		const std::string label;
+		uint64_t baseTimeoutMs;
+		BackoffAlgorithm backoffAlgorithm;
+		std::optional<uint64_t> maxBackoffTimeoutMs;
+		std::optional<size_t> maxRestarts;
+		std::function<uint64_t()> getTimeMs;
+		const std::function<void()> onDelete;
+		// Others.
+		bool running{ false };
+		size_t expirationCount{ 0 };
+		uint64_t expiresAtMs{ std::numeric_limits<uint64_t>::max() };
+	};
+} // namespace mocks
+
+#endif

package/worker/mocks/include/handles/MockTimerHandle.hpp

@@ -0,0 +1,74 @@
+#ifndef MS_MOCKS_MOCK_TIMER_HANDLE_HPP
+#define MS_MOCKS_MOCK_TIMER_HANDLE_HPP
+
+#include "common.hpp"
+#include "handles/TimerHandleInterface.hpp"
+
+namespace mocks
+{
+	// Forward declaration.
+	class MockShared;
+
+	class MockTimerHandle : public TimerHandleInterface
+	{
+		// Only MockShared class can invoke the constructor.
+		friend class mocks::MockShared;
+
+	private:
+		explicit MockTimerHandle() = default;
+
+	public:
+		MockTimerHandle& operator=(const MockTimerHandle&) = delete;
+
+		MockTimerHandle(const MockTimerHandle&) = delete;
+
+		~MockTimerHandle() override = default;
+
+	public:
+		void Start(uint64_t timeout, uint64_t repeat = 0) override
+		{
+			this->running = true;
+			this->timeout = timeout;
+			this->repeat  = repeat;
+		}
+
+		void Stop() override
+		{
+			this->running = false;
+		}
+
+		void Restart() override
+		{
+			this->running = true;
+		}
+
+		void Restart(uint64_t timeout, uint64_t repeat = 0) override
+		{
+			this->running = true;
+			this->timeout = timeout;
+			this->repeat  = repeat;
+		}
+
+		uint64_t GetTimeout() const override
+		{
+			return this->timeout;
+		}
+
+		uint64_t GetRepeat() const override
+		{
+			return this->repeat;
+		}
+
+		bool IsActive() const override
+		{
+			return this->running;
+		}
+
+	private:
+		bool running{ false };
+		uint64_t timeout{ 0u };
+		uint64_t repeat{ 0u };
+	};
+} // namespace mocks
+
+#endif

package/worker/mocks/include/mockTypes.hpp

@@ -0,0 +1,15 @@
+#ifndef MS_MOCKS_TYPES_HPP
+#define MS_MOCKS_TYPES_HPP
+
+#include <string>
+
+namespace mocks
+{
+	struct VerificationResult
+	{
+		bool ok;
+		std::string errorMessage;
+	};
+} // namespace mocks
+
+#endif