mediasoup-sys 0.12.2

FFI bindings to C++ libmediasoup-worker
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

#include "common.hpp"
#include "DepLibUV.hpp"
#include "RTC/SCTP/association/AssociationListenerDeferrer.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;
	RTC::SCTP::AssociationListenerDeferrer associationListenerDeferrer(
	  std::addressof(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(
		  associationListenerDeferrer,
		  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(
		  associationListenerDeferrer,
		  sctpOptions,
		  std::addressof(shared),
		  sendQueue,
		  packetSender,
		  LocalVerificationTag,
		  RemoteVerificationTag,
		  LocalInitialTsn,
		  RemoteInitialTsn,
		  Arwnd,
		  TieTag,
		  negotiatedCapabilities,
		  /*maxPacketLength*/ 1200,
		  isAssociationEstablished);

		REQUIRE_VERIFICATION_RESULT(sendQueue.VerifyExpectations());
	}
}