blob: 770892cbe1c6844580ba48e12dcebad983e11d85 [file] [log] [blame]
wu@webrtc.orgd64719d2013-08-01 00:00:071/*
kjellanderb24317b2016-02-10 15:54:432 * Copyright 2013 The WebRTC project authors. All Rights Reserved.
wu@webrtc.orgd64719d2013-08-01 00:00:073 *
kjellanderb24317b2016-02-10 15:54:434 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
wu@webrtc.orgd64719d2013-08-01 00:00:079 */
10
Yves Gerey3e707812018-11-28 15:47:4911#include <string.h>
Jonas Olssona4d87372019-07-05 17:08:3312
kwibergd1fe2812016-04-27 13:47:2913#include <memory>
Steve Anton36b29d12017-10-30 16:57:4214#include <vector>
kwibergd1fe2812016-04-27 13:47:2915
Florent Castellidcb9ffc2021-06-29 12:58:2316#include "media/sctp/sctp_transport_internal.h"
Taylor Brandstetter3a034e12020-07-09 22:32:3417#include "pc/sctp_data_channel.h"
Steve Anton10542f22019-01-11 17:11:0018#include "pc/sctp_utils.h"
19#include "pc/test/fake_data_channel_provider.h"
Mirko Bonadei92ea95e2017-09-15 04:47:3120#include "rtc_base/gunit.h"
Mirko Bonadeie12c1fe2018-07-03 10:53:2321#include "rtc_base/numerics/safe_conversions.h"
Yves Gerey3e707812018-11-28 15:47:4922#include "test/gtest.h"
wu@webrtc.orgd64719d2013-08-01 00:00:0723
Taylor Brandstetter3a034e12020-07-09 22:32:3424using webrtc::DataChannelInterface;
25using webrtc::SctpDataChannel;
deadbeefab9b2d12015-10-14 18:33:1126using webrtc::SctpSidAllocator;
wu@webrtc.orgd64719d2013-08-01 00:00:0727
Taylor Brandstetter4cb5b642016-08-12 17:10:3128static constexpr int kDefaultTimeout = 10000;
29
sergeyu@chromium.orga23f0ca2013-11-13 22:48:5230class FakeDataChannelObserver : public webrtc::DataChannelObserver {
31 public:
jiayl@webrtc.org9f8164c2014-05-30 21:53:1732 FakeDataChannelObserver()
bemasc0edd50c2015-07-01 20:34:3333 : messages_received_(0),
34 on_state_change_count_(0),
35 on_buffered_amount_change_count_(0) {}
jiayl@webrtc.org5dc51fb2014-05-29 15:33:5436
Yves Gerey665174f2018-06-19 13:03:0537 void OnStateChange() { ++on_state_change_count_; }
jiayl@webrtc.org9f8164c2014-05-30 21:53:1738
Peter Boström0c4e06b2015-10-07 10:23:2139 void OnBufferedAmountChange(uint64_t previous_amount) {
bemasc0edd50c2015-07-01 20:34:3340 ++on_buffered_amount_change_count_;
41 }
42
Yves Gerey665174f2018-06-19 13:03:0543 void OnMessage(const webrtc::DataBuffer& buffer) { ++messages_received_; }
jiayl@webrtc.org5dc51fb2014-05-29 15:33:5444
Yves Gerey665174f2018-06-19 13:03:0545 size_t messages_received() const { return messages_received_; }
jiayl@webrtc.org5dc51fb2014-05-29 15:33:5446
Yves Gerey665174f2018-06-19 13:03:0547 void ResetOnStateChangeCount() { on_state_change_count_ = 0; }
jiayl@webrtc.org9f8164c2014-05-30 21:53:1748
bemasc0edd50c2015-07-01 20:34:3349 void ResetOnBufferedAmountChangeCount() {
50 on_buffered_amount_change_count_ = 0;
51 }
52
Yves Gerey665174f2018-06-19 13:03:0553 size_t on_state_change_count() const { return on_state_change_count_; }
jiayl@webrtc.org9f8164c2014-05-30 21:53:1754
bemasc0edd50c2015-07-01 20:34:3355 size_t on_buffered_amount_change_count() const {
56 return on_buffered_amount_change_count_;
57 }
58
jiayl@webrtc.org5dc51fb2014-05-29 15:33:5459 private:
60 size_t messages_received_;
jiayl@webrtc.org9f8164c2014-05-30 21:53:1761 size_t on_state_change_count_;
bemasc0edd50c2015-07-01 20:34:3362 size_t on_buffered_amount_change_count_;
sergeyu@chromium.orga23f0ca2013-11-13 22:48:5263};
64
Taylor Brandstettercdd05f02018-05-31 20:23:3265// TODO(deadbeef): The fact that these tests use a fake provider makes them not
66// too valuable. Should rewrite using the
67// peerconnection_datachannel_unittest.cc infrastructure.
Tomas Gunnarsson7d3cfbf2020-06-15 11:47:4268// TODO(bugs.webrtc.org/11547): Incorporate a dedicated network thread.
Mirko Bonadei6a489f22019-04-09 13:11:1269class SctpDataChannelTest : public ::testing::Test {
wu@webrtc.orgd64719d2013-08-01 00:00:0770 protected:
71 SctpDataChannelTest()
Taylor Brandstetter4cb5b642016-08-12 17:10:3172 : provider_(new FakeDataChannelProvider()),
Taylor Brandstetter3a034e12020-07-09 22:32:3473 webrtc_data_channel_(SctpDataChannel::Create(provider_.get(),
74 "test",
75 init_,
76 rtc::Thread::Current(),
77 rtc::Thread::Current())) {}
wu@webrtc.orgd64719d2013-08-01 00:00:0778
wu@webrtc.org78187522013-10-07 23:32:0279 void SetChannelReady() {
Taylor Brandstetter4cb5b642016-08-12 17:10:3180 provider_->set_transport_available(true);
wu@webrtc.orgcecfd182013-10-30 05:18:1281 webrtc_data_channel_->OnTransportChannelCreated();
82 if (webrtc_data_channel_->id() < 0) {
83 webrtc_data_channel_->SetSctpSid(0);
84 }
Taylor Brandstetter4cb5b642016-08-12 17:10:3185 provider_->set_ready_to_send(true);
wu@webrtc.orgd64719d2013-08-01 00:00:0786 }
wu@webrtc.org78187522013-10-07 23:32:0287
sergeyu@chromium.orga23f0ca2013-11-13 22:48:5288 void AddObserver() {
89 observer_.reset(new FakeDataChannelObserver());
90 webrtc_data_channel_->RegisterObserver(observer_.get());
91 }
92
henrika@webrtc.orgaebb1ad2014-01-14 10:00:5893 webrtc::InternalDataChannelInit init_;
Taylor Brandstetter4cb5b642016-08-12 17:10:3194 std::unique_ptr<FakeDataChannelProvider> provider_;
kwibergd1fe2812016-04-27 13:47:2995 std::unique_ptr<FakeDataChannelObserver> observer_;
Taylor Brandstetter3a034e12020-07-09 22:32:3496 rtc::scoped_refptr<SctpDataChannel> webrtc_data_channel_;
wu@webrtc.orgd64719d2013-08-01 00:00:0797};
98
hbos82ebe022016-11-14 09:41:0999class StateSignalsListener : public sigslot::has_slots<> {
100 public:
101 int opened_count() const { return opened_count_; }
102 int closed_count() const { return closed_count_; }
103
Taylor Brandstetter3a034e12020-07-09 22:32:34104 void OnSignalOpened(DataChannelInterface* data_channel) { ++opened_count_; }
hbos82ebe022016-11-14 09:41:09105
Taylor Brandstetter3a034e12020-07-09 22:32:34106 void OnSignalClosed(DataChannelInterface* data_channel) { ++closed_count_; }
hbos82ebe022016-11-14 09:41:09107
108 private:
109 int opened_count_ = 0;
110 int closed_count_ = 0;
111};
112
wu@webrtc.orgcecfd182013-10-30 05:18:12113// Verifies that the data channel is connected to the transport after creation.
114TEST_F(SctpDataChannelTest, ConnectedToTransportOnCreated) {
Taylor Brandstetter4cb5b642016-08-12 17:10:31115 provider_->set_transport_available(true);
Taylor Brandstetter3a034e12020-07-09 22:32:34116 rtc::scoped_refptr<SctpDataChannel> dc =
117 SctpDataChannel::Create(provider_.get(), "test1", init_,
118 rtc::Thread::Current(), rtc::Thread::Current());
wu@webrtc.orgcecfd182013-10-30 05:18:12119
Taylor Brandstetter4cb5b642016-08-12 17:10:31120 EXPECT_TRUE(provider_->IsConnected(dc.get()));
wu@webrtc.org07a6fbe2013-11-04 18:41:34121 // The sid is not set yet, so it should not have added the streams.
Taylor Brandstetter4cb5b642016-08-12 17:10:31122 EXPECT_FALSE(provider_->IsSendStreamAdded(dc->id()));
123 EXPECT_FALSE(provider_->IsRecvStreamAdded(dc->id()));
wu@webrtc.org07a6fbe2013-11-04 18:41:34124
125 dc->SetSctpSid(0);
Taylor Brandstetter4cb5b642016-08-12 17:10:31126 EXPECT_TRUE(provider_->IsSendStreamAdded(dc->id()));
127 EXPECT_TRUE(provider_->IsRecvStreamAdded(dc->id()));
wu@webrtc.orgcecfd182013-10-30 05:18:12128}
129
130// Verifies that the data channel is connected to the transport if the transport
131// is not available initially and becomes available later.
132TEST_F(SctpDataChannelTest, ConnectedAfterTransportBecomesAvailable) {
Taylor Brandstetter4cb5b642016-08-12 17:10:31133 EXPECT_FALSE(provider_->IsConnected(webrtc_data_channel_.get()));
wu@webrtc.orgcecfd182013-10-30 05:18:12134
Taylor Brandstetter4cb5b642016-08-12 17:10:31135 provider_->set_transport_available(true);
wu@webrtc.org07a6fbe2013-11-04 18:41:34136 webrtc_data_channel_->OnTransportChannelCreated();
Taylor Brandstetter4cb5b642016-08-12 17:10:31137 EXPECT_TRUE(provider_->IsConnected(webrtc_data_channel_.get()));
wu@webrtc.orgcecfd182013-10-30 05:18:12138}
139
wu@webrtc.org78187522013-10-07 23:32:02140// Tests the state of the data channel.
141TEST_F(SctpDataChannelTest, StateTransition) {
hbos82ebe022016-11-14 09:41:09142 StateSignalsListener state_signals_listener;
143 webrtc_data_channel_->SignalOpened.connect(
144 &state_signals_listener, &StateSignalsListener::OnSignalOpened);
145 webrtc_data_channel_->SignalClosed.connect(
146 &state_signals_listener, &StateSignalsListener::OnSignalClosed);
wu@webrtc.org78187522013-10-07 23:32:02147 EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
148 webrtc_data_channel_->state());
hbos82ebe022016-11-14 09:41:09149 EXPECT_EQ(state_signals_listener.opened_count(), 0);
150 EXPECT_EQ(state_signals_listener.closed_count(), 0);
wu@webrtc.org78187522013-10-07 23:32:02151 SetChannelReady();
wu@webrtc.org07a6fbe2013-11-04 18:41:34152
wu@webrtc.org78187522013-10-07 23:32:02153 EXPECT_EQ(webrtc::DataChannelInterface::kOpen, webrtc_data_channel_->state());
hbos82ebe022016-11-14 09:41:09154 EXPECT_EQ(state_signals_listener.opened_count(), 1);
155 EXPECT_EQ(state_signals_listener.closed_count(), 0);
wu@webrtc.org78187522013-10-07 23:32:02156 webrtc_data_channel_->Close();
157 EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
158 webrtc_data_channel_->state());
Harald Alvestranddfbfb462019-12-08 04:55:43159 EXPECT_TRUE(webrtc_data_channel_->error().ok());
hbos82ebe022016-11-14 09:41:09160 EXPECT_EQ(state_signals_listener.opened_count(), 1);
161 EXPECT_EQ(state_signals_listener.closed_count(), 1);
wu@webrtc.orgcecfd182013-10-30 05:18:12162 // Verifies that it's disconnected from the transport.
Taylor Brandstetter4cb5b642016-08-12 17:10:31163 EXPECT_FALSE(provider_->IsConnected(webrtc_data_channel_.get()));
wu@webrtc.org78187522013-10-07 23:32:02164}
165
wu@webrtc.orgd64719d2013-08-01 00:00:07166// Tests that DataChannel::buffered_amount() is correct after the channel is
167// blocked.
168TEST_F(SctpDataChannelTest, BufferedAmountWhenBlocked) {
bemasc0edd50c2015-07-01 20:34:33169 AddObserver();
wu@webrtc.org78187522013-10-07 23:32:02170 SetChannelReady();
wu@webrtc.orgd64719d2013-08-01 00:00:07171 webrtc::DataBuffer buffer("abcd");
172 EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
Marina Cioceae448a3f2019-03-04 14:52:21173 size_t successful_send_count = 1;
wu@webrtc.orgd64719d2013-08-01 00:00:07174
175 EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
Marina Cioceae448a3f2019-03-04 14:52:21176 EXPECT_EQ(successful_send_count,
177 observer_->on_buffered_amount_change_count());
wu@webrtc.orgd64719d2013-08-01 00:00:07178
Taylor Brandstetter4cb5b642016-08-12 17:10:31179 provider_->set_send_blocked(true);
wu@webrtc.org78187522013-10-07 23:32:02180
wu@webrtc.orgd64719d2013-08-01 00:00:07181 const int number_of_packets = 3;
182 for (int i = 0; i < number_of_packets; ++i) {
183 EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
184 }
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06185 EXPECT_EQ(buffer.data.size() * number_of_packets,
wu@webrtc.orgd64719d2013-08-01 00:00:07186 webrtc_data_channel_->buffered_amount());
Marina Cioceae448a3f2019-03-04 14:52:21187 EXPECT_EQ(successful_send_count,
188 observer_->on_buffered_amount_change_count());
189
190 provider_->set_send_blocked(false);
191 successful_send_count += number_of_packets;
192 EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
193 EXPECT_EQ(successful_send_count,
Mirko Bonadeie12c1fe2018-07-03 10:53:23194 observer_->on_buffered_amount_change_count());
wu@webrtc.orgd64719d2013-08-01 00:00:07195}
196
197// Tests that the queued data are sent when the channel transitions from blocked
198// to unblocked.
199TEST_F(SctpDataChannelTest, QueuedDataSentWhenUnblocked) {
bemasc0edd50c2015-07-01 20:34:33200 AddObserver();
wu@webrtc.org78187522013-10-07 23:32:02201 SetChannelReady();
wu@webrtc.orgd64719d2013-08-01 00:00:07202 webrtc::DataBuffer buffer("abcd");
Taylor Brandstetter4cb5b642016-08-12 17:10:31203 provider_->set_send_blocked(true);
wu@webrtc.orgd64719d2013-08-01 00:00:07204 EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
205
Marina Cioceae448a3f2019-03-04 14:52:21206 EXPECT_EQ(0U, observer_->on_buffered_amount_change_count());
bemasc0edd50c2015-07-01 20:34:33207
Taylor Brandstetter4cb5b642016-08-12 17:10:31208 provider_->set_send_blocked(false);
wu@webrtc.org78187522013-10-07 23:32:02209 SetChannelReady();
wu@webrtc.orgd64719d2013-08-01 00:00:07210 EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
Marina Cioceae448a3f2019-03-04 14:52:21211 EXPECT_EQ(1U, observer_->on_buffered_amount_change_count());
wu@webrtc.orgd64719d2013-08-01 00:00:07212}
wu@webrtc.org78187522013-10-07 23:32:02213
jiayl@webrtc.orgcceb1662015-01-22 00:55:10214// Tests that no crash when the channel is blocked right away while trying to
215// send queued data.
216TEST_F(SctpDataChannelTest, BlockedWhenSendQueuedDataNoCrash) {
bemasc0edd50c2015-07-01 20:34:33217 AddObserver();
jiayl@webrtc.orgcceb1662015-01-22 00:55:10218 SetChannelReady();
219 webrtc::DataBuffer buffer("abcd");
Taylor Brandstetter4cb5b642016-08-12 17:10:31220 provider_->set_send_blocked(true);
jiayl@webrtc.orgcceb1662015-01-22 00:55:10221 EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
Marina Cioceae448a3f2019-03-04 14:52:21222 EXPECT_EQ(0U, observer_->on_buffered_amount_change_count());
jiayl@webrtc.orgcceb1662015-01-22 00:55:10223
224 // Set channel ready while it is still blocked.
225 SetChannelReady();
226 EXPECT_EQ(buffer.size(), webrtc_data_channel_->buffered_amount());
Marina Cioceae448a3f2019-03-04 14:52:21227 EXPECT_EQ(0U, observer_->on_buffered_amount_change_count());
jiayl@webrtc.orgcceb1662015-01-22 00:55:10228
229 // Unblock the channel to send queued data again, there should be no crash.
Taylor Brandstetter4cb5b642016-08-12 17:10:31230 provider_->set_send_blocked(false);
jiayl@webrtc.orgcceb1662015-01-22 00:55:10231 SetChannelReady();
232 EXPECT_EQ(0U, webrtc_data_channel_->buffered_amount());
Marina Cioceae448a3f2019-03-04 14:52:21233 EXPECT_EQ(1U, observer_->on_buffered_amount_change_count());
jiayl@webrtc.orgcceb1662015-01-22 00:55:10234}
235
hbos84ffdee2016-10-12 21:14:39236// Tests that DataChannel::messages_sent() and DataChannel::bytes_sent() are
237// correct, sending data both while unblocked and while blocked.
238TEST_F(SctpDataChannelTest, VerifyMessagesAndBytesSent) {
239 AddObserver();
240 SetChannelReady();
241 std::vector<webrtc::DataBuffer> buffers({
Jonas Olssona4d87372019-07-05 17:08:33242 webrtc::DataBuffer("message 1"),
243 webrtc::DataBuffer("msg 2"),
244 webrtc::DataBuffer("message three"),
245 webrtc::DataBuffer("quadra message"),
Yves Gerey665174f2018-06-19 13:03:05246 webrtc::DataBuffer("fifthmsg"),
247 webrtc::DataBuffer("message of the beast"),
hbos84ffdee2016-10-12 21:14:39248 });
249
250 // Default values.
251 EXPECT_EQ(0U, webrtc_data_channel_->messages_sent());
252 EXPECT_EQ(0U, webrtc_data_channel_->bytes_sent());
253
254 // Send three buffers while not blocked.
255 provider_->set_send_blocked(false);
256 EXPECT_TRUE(webrtc_data_channel_->Send(buffers[0]));
257 EXPECT_TRUE(webrtc_data_channel_->Send(buffers[1]));
258 EXPECT_TRUE(webrtc_data_channel_->Send(buffers[2]));
259 size_t bytes_sent = buffers[0].size() + buffers[1].size() + buffers[2].size();
260 EXPECT_EQ_WAIT(0U, webrtc_data_channel_->buffered_amount(), kDefaultTimeout);
261 EXPECT_EQ(3U, webrtc_data_channel_->messages_sent());
262 EXPECT_EQ(bytes_sent, webrtc_data_channel_->bytes_sent());
263
264 // Send three buffers while blocked, queuing the buffers.
265 provider_->set_send_blocked(true);
266 EXPECT_TRUE(webrtc_data_channel_->Send(buffers[3]));
267 EXPECT_TRUE(webrtc_data_channel_->Send(buffers[4]));
268 EXPECT_TRUE(webrtc_data_channel_->Send(buffers[5]));
269 size_t bytes_queued =
270 buffers[3].size() + buffers[4].size() + buffers[5].size();
271 EXPECT_EQ(bytes_queued, webrtc_data_channel_->buffered_amount());
272 EXPECT_EQ(3U, webrtc_data_channel_->messages_sent());
273 EXPECT_EQ(bytes_sent, webrtc_data_channel_->bytes_sent());
274
275 // Unblock and make sure everything was sent.
276 provider_->set_send_blocked(false);
277 EXPECT_EQ_WAIT(0U, webrtc_data_channel_->buffered_amount(), kDefaultTimeout);
278 bytes_sent += bytes_queued;
279 EXPECT_EQ(6U, webrtc_data_channel_->messages_sent());
280 EXPECT_EQ(bytes_sent, webrtc_data_channel_->bytes_sent());
281}
282
wu@webrtc.org78187522013-10-07 23:32:02283// Tests that the queued control message is sent when channel is ready.
wu@webrtc.orgcecfd182013-10-30 05:18:12284TEST_F(SctpDataChannelTest, OpenMessageSent) {
285 // Initially the id is unassigned.
286 EXPECT_EQ(-1, webrtc_data_channel_->id());
287
wu@webrtc.org78187522013-10-07 23:32:02288 SetChannelReady();
wu@webrtc.orgcecfd182013-10-30 05:18:12289 EXPECT_GE(webrtc_data_channel_->id(), 0);
Florent Castellid95b1492021-05-10 09:29:56290 EXPECT_EQ(webrtc::DataMessageType::kControl,
291 provider_->last_send_data_params().type);
292 EXPECT_EQ(provider_->last_sid(), webrtc_data_channel_->id());
wu@webrtc.org78187522013-10-07 23:32:02293}
wu@webrtc.org07a6fbe2013-11-04 18:41:34294
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14295TEST_F(SctpDataChannelTest, QueuedOpenMessageSent) {
Taylor Brandstetter4cb5b642016-08-12 17:10:31296 provider_->set_send_blocked(true);
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14297 SetChannelReady();
Taylor Brandstetter4cb5b642016-08-12 17:10:31298 provider_->set_send_blocked(false);
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14299
Florent Castellid95b1492021-05-10 09:29:56300 EXPECT_EQ(webrtc::DataMessageType::kControl,
301 provider_->last_send_data_params().type);
302 EXPECT_EQ(provider_->last_sid(), webrtc_data_channel_->id());
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14303}
304
wu@webrtc.org07a6fbe2013-11-04 18:41:34305// Tests that the DataChannel created after transport gets ready can enter OPEN
306// state.
307TEST_F(SctpDataChannelTest, LateCreatedChannelTransitionToOpen) {
308 SetChannelReady();
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58309 webrtc::InternalDataChannelInit init;
wu@webrtc.org07a6fbe2013-11-04 18:41:34310 init.id = 1;
Taylor Brandstetter3a034e12020-07-09 22:32:34311 rtc::scoped_refptr<SctpDataChannel> dc =
312 SctpDataChannel::Create(provider_.get(), "test1", init,
313 rtc::Thread::Current(), rtc::Thread::Current());
wu@webrtc.org07a6fbe2013-11-04 18:41:34314 EXPECT_EQ(webrtc::DataChannelInterface::kConnecting, dc->state());
Yves Gerey665174f2018-06-19 13:03:05315 EXPECT_TRUE_WAIT(webrtc::DataChannelInterface::kOpen == dc->state(), 1000);
wu@webrtc.org07a6fbe2013-11-04 18:41:34316}
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52317
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58318// Tests that an unordered DataChannel sends data as ordered until the OPEN_ACK
319// message is received.
320TEST_F(SctpDataChannelTest, SendUnorderedAfterReceivesOpenAck) {
321 SetChannelReady();
322 webrtc::InternalDataChannelInit init;
323 init.id = 1;
324 init.ordered = false;
Taylor Brandstetter3a034e12020-07-09 22:32:34325 rtc::scoped_refptr<SctpDataChannel> dc =
326 SctpDataChannel::Create(provider_.get(), "test1", init,
327 rtc::Thread::Current(), rtc::Thread::Current());
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58328
329 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
330
331 // Sends a message and verifies it's ordered.
332 webrtc::DataBuffer buffer("some data");
333 ASSERT_TRUE(dc->Send(buffer));
Taylor Brandstetter4cb5b642016-08-12 17:10:31334 EXPECT_TRUE(provider_->last_send_data_params().ordered);
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58335
336 // Emulates receiving an OPEN_ACK message.
337 cricket::ReceiveDataParams params;
Harald Alvestrand7af57c62021-04-16 11:12:14338 params.sid = init.id;
Florent Castellid95b1492021-05-10 09:29:56339 params.type = webrtc::DataMessageType::kControl;
jbaucheec21bd2016-03-20 13:15:43340 rtc::CopyOnWriteBuffer payload;
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58341 webrtc::WriteDataChannelOpenAckMessage(&payload);
deadbeef953c2ce2017-01-09 22:53:41342 dc->OnDataReceived(params, payload);
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58343
344 // Sends another message and verifies it's unordered.
345 ASSERT_TRUE(dc->Send(buffer));
Taylor Brandstetter4cb5b642016-08-12 17:10:31346 EXPECT_FALSE(provider_->last_send_data_params().ordered);
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58347}
348
349// Tests that an unordered DataChannel sends unordered data after any DATA
350// message is received.
351TEST_F(SctpDataChannelTest, SendUnorderedAfterReceiveData) {
352 SetChannelReady();
353 webrtc::InternalDataChannelInit init;
354 init.id = 1;
355 init.ordered = false;
Taylor Brandstetter3a034e12020-07-09 22:32:34356 rtc::scoped_refptr<SctpDataChannel> dc =
357 SctpDataChannel::Create(provider_.get(), "test1", init,
358 rtc::Thread::Current(), rtc::Thread::Current());
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58359
360 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
361
362 // Emulates receiving a DATA message.
363 cricket::ReceiveDataParams params;
Harald Alvestrand7af57c62021-04-16 11:12:14364 params.sid = init.id;
Florent Castellid95b1492021-05-10 09:29:56365 params.type = webrtc::DataMessageType::kText;
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58366 webrtc::DataBuffer buffer("data");
deadbeef953c2ce2017-01-09 22:53:41367 dc->OnDataReceived(params, buffer.data);
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58368
369 // Sends a message and verifies it's unordered.
370 ASSERT_TRUE(dc->Send(buffer));
Taylor Brandstetter4cb5b642016-08-12 17:10:31371 EXPECT_FALSE(provider_->last_send_data_params().ordered);
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58372}
373
Lally Singh5c6c6e02015-05-29 15:52:39374// Tests that the channel can't open until it's successfully sent the OPEN
375// message.
376TEST_F(SctpDataChannelTest, OpenWaitsForOpenMesssage) {
377 webrtc::DataBuffer buffer("foo");
378
Taylor Brandstetter4cb5b642016-08-12 17:10:31379 provider_->set_send_blocked(true);
Lally Singh5c6c6e02015-05-29 15:52:39380 SetChannelReady();
381 EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
382 webrtc_data_channel_->state());
Taylor Brandstetter4cb5b642016-08-12 17:10:31383 provider_->set_send_blocked(false);
Lally Singh5c6c6e02015-05-29 15:52:39384 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen,
385 webrtc_data_channel_->state(), 1000);
Florent Castellid95b1492021-05-10 09:29:56386 EXPECT_EQ(webrtc::DataMessageType::kControl,
387 provider_->last_send_data_params().type);
Lally Singh5c6c6e02015-05-29 15:52:39388}
389
390// Tests that close first makes sure all queued data gets sent.
391TEST_F(SctpDataChannelTest, QueuedCloseFlushes) {
392 webrtc::DataBuffer buffer("foo");
393
Taylor Brandstetter4cb5b642016-08-12 17:10:31394 provider_->set_send_blocked(true);
Lally Singh5c6c6e02015-05-29 15:52:39395 SetChannelReady();
396 EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
397 webrtc_data_channel_->state());
Taylor Brandstetter4cb5b642016-08-12 17:10:31398 provider_->set_send_blocked(false);
Lally Singh5c6c6e02015-05-29 15:52:39399 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen,
400 webrtc_data_channel_->state(), 1000);
Taylor Brandstetter4cb5b642016-08-12 17:10:31401 provider_->set_send_blocked(true);
Lally Singh5c6c6e02015-05-29 15:52:39402 webrtc_data_channel_->Send(buffer);
403 webrtc_data_channel_->Close();
Taylor Brandstetter4cb5b642016-08-12 17:10:31404 provider_->set_send_blocked(false);
Lally Singh5c6c6e02015-05-29 15:52:39405 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kClosed,
406 webrtc_data_channel_->state(), 1000);
Harald Alvestranddfbfb462019-12-08 04:55:43407 EXPECT_TRUE(webrtc_data_channel_->error().ok());
Florent Castellid95b1492021-05-10 09:29:56408 EXPECT_EQ(webrtc::DataMessageType::kText,
409 provider_->last_send_data_params().type);
Lally Singh5c6c6e02015-05-29 15:52:39410}
411
Harald Alvestrand7af57c62021-04-16 11:12:14412// Tests that messages are sent with the right id.
413TEST_F(SctpDataChannelTest, SendDataId) {
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52414 webrtc_data_channel_->SetSctpSid(1);
415 SetChannelReady();
416 webrtc::DataBuffer buffer("data");
417 EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
Florent Castellid95b1492021-05-10 09:29:56418 EXPECT_EQ(1, provider_->last_sid());
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52419}
420
Harald Alvestrand7af57c62021-04-16 11:12:14421// Tests that the incoming messages with wrong ids are rejected.
422TEST_F(SctpDataChannelTest, ReceiveDataWithInvalidId) {
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52423 webrtc_data_channel_->SetSctpSid(1);
424 SetChannelReady();
425
426 AddObserver();
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52427
428 cricket::ReceiveDataParams params;
Harald Alvestrand7af57c62021-04-16 11:12:14429 params.sid = 0;
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52430 webrtc::DataBuffer buffer("abcd");
deadbeef953c2ce2017-01-09 22:53:41431 webrtc_data_channel_->OnDataReceived(params, buffer.data);
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54432
433 EXPECT_EQ(0U, observer_->messages_received());
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52434}
435
Harald Alvestrand7af57c62021-04-16 11:12:14436// Tests that the incoming messages with right ids are accepted.
437TEST_F(SctpDataChannelTest, ReceiveDataWithValidId) {
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52438 webrtc_data_channel_->SetSctpSid(1);
439 SetChannelReady();
440
441 AddObserver();
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52442
443 cricket::ReceiveDataParams params;
Harald Alvestrand7af57c62021-04-16 11:12:14444 params.sid = 1;
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52445 webrtc::DataBuffer buffer("abcd");
446
deadbeef953c2ce2017-01-09 22:53:41447 webrtc_data_channel_->OnDataReceived(params, buffer.data);
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54448 EXPECT_EQ(1U, observer_->messages_received());
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52449}
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58450
451// Tests that no CONTROL message is sent if the datachannel is negotiated and
452// not created from an OPEN message.
453TEST_F(SctpDataChannelTest, NoMsgSentIfNegotiatedAndNotFromOpenMsg) {
454 webrtc::InternalDataChannelInit config;
455 config.id = 1;
456 config.negotiated = true;
457 config.open_handshake_role = webrtc::InternalDataChannelInit::kNone;
458
459 SetChannelReady();
Taylor Brandstetter3a034e12020-07-09 22:32:34460 rtc::scoped_refptr<SctpDataChannel> dc =
461 SctpDataChannel::Create(provider_.get(), "test1", config,
462 rtc::Thread::Current(), rtc::Thread::Current());
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58463
464 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
Florent Castellid95b1492021-05-10 09:29:56465 EXPECT_EQ(0, provider_->last_sid());
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58466}
467
hbos84ffdee2016-10-12 21:14:39468// Tests that DataChannel::messages_received() and DataChannel::bytes_received()
469// are correct, receiving data both while not open and while open.
470TEST_F(SctpDataChannelTest, VerifyMessagesAndBytesReceived) {
471 AddObserver();
472 std::vector<webrtc::DataBuffer> buffers({
Jonas Olssona4d87372019-07-05 17:08:33473 webrtc::DataBuffer("message 1"),
474 webrtc::DataBuffer("msg 2"),
475 webrtc::DataBuffer("message three"),
476 webrtc::DataBuffer("quadra message"),
Yves Gerey665174f2018-06-19 13:03:05477 webrtc::DataBuffer("fifthmsg"),
478 webrtc::DataBuffer("message of the beast"),
hbos84ffdee2016-10-12 21:14:39479 });
480
481 webrtc_data_channel_->SetSctpSid(1);
482 cricket::ReceiveDataParams params;
Harald Alvestrand7af57c62021-04-16 11:12:14483 params.sid = 1;
hbos84ffdee2016-10-12 21:14:39484
485 // Default values.
486 EXPECT_EQ(0U, webrtc_data_channel_->messages_received());
487 EXPECT_EQ(0U, webrtc_data_channel_->bytes_received());
488
489 // Receive three buffers while data channel isn't open.
deadbeef953c2ce2017-01-09 22:53:41490 webrtc_data_channel_->OnDataReceived(params, buffers[0].data);
491 webrtc_data_channel_->OnDataReceived(params, buffers[1].data);
492 webrtc_data_channel_->OnDataReceived(params, buffers[2].data);
hbos84ffdee2016-10-12 21:14:39493 EXPECT_EQ(0U, observer_->messages_received());
494 EXPECT_EQ(0U, webrtc_data_channel_->messages_received());
495 EXPECT_EQ(0U, webrtc_data_channel_->bytes_received());
496
497 // Open channel and make sure everything was received.
498 SetChannelReady();
499 size_t bytes_received =
500 buffers[0].size() + buffers[1].size() + buffers[2].size();
501 EXPECT_EQ(3U, observer_->messages_received());
502 EXPECT_EQ(3U, webrtc_data_channel_->messages_received());
503 EXPECT_EQ(bytes_received, webrtc_data_channel_->bytes_received());
504
505 // Receive three buffers while open.
deadbeef953c2ce2017-01-09 22:53:41506 webrtc_data_channel_->OnDataReceived(params, buffers[3].data);
507 webrtc_data_channel_->OnDataReceived(params, buffers[4].data);
508 webrtc_data_channel_->OnDataReceived(params, buffers[5].data);
hbos84ffdee2016-10-12 21:14:39509 bytes_received += buffers[3].size() + buffers[4].size() + buffers[5].size();
510 EXPECT_EQ(6U, observer_->messages_received());
511 EXPECT_EQ(6U, webrtc_data_channel_->messages_received());
512 EXPECT_EQ(bytes_received, webrtc_data_channel_->bytes_received());
513}
514
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58515// Tests that OPEN_ACK message is sent if the datachannel is created from an
516// OPEN message.
517TEST_F(SctpDataChannelTest, OpenAckSentIfCreatedFromOpenMessage) {
518 webrtc::InternalDataChannelInit config;
519 config.id = 1;
520 config.negotiated = true;
521 config.open_handshake_role = webrtc::InternalDataChannelInit::kAcker;
522
523 SetChannelReady();
Taylor Brandstetter3a034e12020-07-09 22:32:34524 rtc::scoped_refptr<SctpDataChannel> dc =
525 SctpDataChannel::Create(provider_.get(), "test1", config,
526 rtc::Thread::Current(), rtc::Thread::Current());
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58527
528 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
529
Florent Castellid95b1492021-05-10 09:29:56530 EXPECT_EQ(config.id, provider_->last_sid());
531 EXPECT_EQ(webrtc::DataMessageType::kControl,
532 provider_->last_send_data_params().type);
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58533}
534
535// Tests the OPEN_ACK role assigned by InternalDataChannelInit.
536TEST_F(SctpDataChannelTest, OpenAckRoleInitialization) {
537 webrtc::InternalDataChannelInit init;
538 EXPECT_EQ(webrtc::InternalDataChannelInit::kOpener, init.open_handshake_role);
539 EXPECT_FALSE(init.negotiated);
540
541 webrtc::DataChannelInit base;
542 base.negotiated = true;
543 webrtc::InternalDataChannelInit init2(base);
544 EXPECT_EQ(webrtc::InternalDataChannelInit::kNone, init2.open_handshake_role);
545}
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54546
547// Tests that the DataChannel is closed if the sending buffer is full.
548TEST_F(SctpDataChannelTest, ClosedWhenSendBufferFull) {
549 SetChannelReady();
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14550
jbaucheec21bd2016-03-20 13:15:43551 rtc::CopyOnWriteBuffer buffer(1024);
Danil Chapovalove15dc582021-01-07 14:24:05552 memset(buffer.MutableData(), 0, buffer.size());
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14553
554 webrtc::DataBuffer packet(buffer, true);
Taylor Brandstetter4cb5b642016-08-12 17:10:31555 provider_->set_send_blocked(true);
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54556
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14557 for (size_t i = 0; i < 16 * 1024 + 1; ++i) {
558 EXPECT_TRUE(webrtc_data_channel_->Send(packet));
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54559 }
560
Lally Singh5c6c6e02015-05-29 15:52:39561 EXPECT_TRUE(
562 webrtc::DataChannelInterface::kClosed == webrtc_data_channel_->state() ||
563 webrtc::DataChannelInterface::kClosing == webrtc_data_channel_->state());
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54564}
565
566// Tests that the DataChannel is closed on transport errors.
567TEST_F(SctpDataChannelTest, ClosedOnTransportError) {
568 SetChannelReady();
569 webrtc::DataBuffer buffer("abcd");
Taylor Brandstetter4cb5b642016-08-12 17:10:31570 provider_->set_transport_error();
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54571
572 EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
573
574 EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
575 webrtc_data_channel_->state());
Harald Alvestranddfbfb462019-12-08 04:55:43576 EXPECT_FALSE(webrtc_data_channel_->error().ok());
577 EXPECT_EQ(webrtc::RTCErrorType::NETWORK_ERROR,
578 webrtc_data_channel_->error().type());
579 EXPECT_EQ(webrtc::RTCErrorDetailType::NONE,
580 webrtc_data_channel_->error().error_detail());
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54581}
jiayl@webrtc.org9f8164c2014-05-30 21:53:17582
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14583// Tests that the DataChannel is closed if the received buffer is full.
584TEST_F(SctpDataChannelTest, ClosedWhenReceivedBufferFull) {
585 SetChannelReady();
jbaucheec21bd2016-03-20 13:15:43586 rtc::CopyOnWriteBuffer buffer(1024);
Danil Chapovalove15dc582021-01-07 14:24:05587 memset(buffer.MutableData(), 0, buffer.size());
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14588
589 cricket::ReceiveDataParams params;
Harald Alvestrand7af57c62021-04-16 11:12:14590 params.sid = 0;
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14591
592 // Receiving data without having an observer will overflow the buffer.
593 for (size_t i = 0; i < 16 * 1024 + 1; ++i) {
deadbeef953c2ce2017-01-09 22:53:41594 webrtc_data_channel_->OnDataReceived(params, buffer);
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14595 }
596 EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
597 webrtc_data_channel_->state());
Harald Alvestranddfbfb462019-12-08 04:55:43598 EXPECT_FALSE(webrtc_data_channel_->error().ok());
599 EXPECT_EQ(webrtc::RTCErrorType::RESOURCE_EXHAUSTED,
600 webrtc_data_channel_->error().type());
601 EXPECT_EQ(webrtc::RTCErrorDetailType::NONE,
602 webrtc_data_channel_->error().error_detail());
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14603}
jiayl@webrtc.org3edbaaf2014-07-18 23:57:50604
605// Tests that sending empty data returns no error and keeps the channel open.
606TEST_F(SctpDataChannelTest, SendEmptyData) {
607 webrtc_data_channel_->SetSctpSid(1);
608 SetChannelReady();
Yves Gerey665174f2018-06-19 13:03:05609 EXPECT_EQ(webrtc::DataChannelInterface::kOpen, webrtc_data_channel_->state());
jiayl@webrtc.org3edbaaf2014-07-18 23:57:50610
611 webrtc::DataBuffer buffer("");
612 EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
Yves Gerey665174f2018-06-19 13:03:05613 EXPECT_EQ(webrtc::DataChannelInterface::kOpen, webrtc_data_channel_->state());
jiayl@webrtc.org3edbaaf2014-07-18 23:57:50614}
bemasc@webrtc.org9b5467e2014-12-04 23:16:52615
616// Tests that a channel can be closed without being opened or assigned an sid.
617TEST_F(SctpDataChannelTest, NeverOpened) {
Taylor Brandstetter4cb5b642016-08-12 17:10:31618 provider_->set_transport_available(true);
bemasc@webrtc.org9b5467e2014-12-04 23:16:52619 webrtc_data_channel_->OnTransportChannelCreated();
620 webrtc_data_channel_->Close();
621}
deadbeefab9b2d12015-10-14 18:33:11622
Taylor Brandstetter4cb5b642016-08-12 17:10:31623// Test that the data channel goes to the "closed" state (and doesn't crash)
624// when its transport goes away, even while data is buffered.
625TEST_F(SctpDataChannelTest, TransportDestroyedWhileDataBuffered) {
626 SetChannelReady();
627
628 rtc::CopyOnWriteBuffer buffer(1024);
Danil Chapovalove15dc582021-01-07 14:24:05629 memset(buffer.MutableData(), 0, buffer.size());
Taylor Brandstetter4cb5b642016-08-12 17:10:31630 webrtc::DataBuffer packet(buffer, true);
631
632 // Send a packet while sending is blocked so it ends up buffered.
633 provider_->set_send_blocked(true);
634 EXPECT_TRUE(webrtc_data_channel_->Send(packet));
635
Harald Alvestrand408cb4b2019-11-16 11:09:08636 // Tell the data channel that its transport is being destroyed.
Taylor Brandstetter4cb5b642016-08-12 17:10:31637 // It should then stop using the transport (allowing us to delete it) and
638 // transition to the "closed" state.
Florent Castellidcb9ffc2021-06-29 12:58:23639 webrtc::RTCError error(webrtc::RTCErrorType::OPERATION_ERROR_WITH_DATA, "");
640 error.set_error_detail(webrtc::RTCErrorDetailType::SCTP_FAILURE);
641 webrtc_data_channel_->OnTransportChannelClosed(error);
Taylor Brandstetter4cb5b642016-08-12 17:10:31642 provider_.reset(nullptr);
643 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kClosed,
644 webrtc_data_channel_->state(), kDefaultTimeout);
Harald Alvestranddfbfb462019-12-08 04:55:43645 EXPECT_FALSE(webrtc_data_channel_->error().ok());
Harald Alvestrand37e42be2020-05-12 10:59:02646 EXPECT_EQ(webrtc::RTCErrorType::OPERATION_ERROR_WITH_DATA,
Harald Alvestranddfbfb462019-12-08 04:55:43647 webrtc_data_channel_->error().type());
Harald Alvestrand37e42be2020-05-12 10:59:02648 EXPECT_EQ(webrtc::RTCErrorDetailType::SCTP_FAILURE,
Harald Alvestranddfbfb462019-12-08 04:55:43649 webrtc_data_channel_->error().error_detail());
Taylor Brandstetter4cb5b642016-08-12 17:10:31650}
651
Florent Castellidcb9ffc2021-06-29 12:58:23652TEST_F(SctpDataChannelTest, TransportGotErrorCode) {
653 SetChannelReady();
654
655 // Tell the data channel that its transport is being destroyed with an
656 // error code.
657 // It should then report that error code.
658 webrtc::RTCError error(webrtc::RTCErrorType::OPERATION_ERROR_WITH_DATA,
659 "Transport channel closed");
660 error.set_error_detail(webrtc::RTCErrorDetailType::SCTP_FAILURE);
661 error.set_sctp_cause_code(
662 static_cast<uint16_t>(cricket::SctpErrorCauseCode::kProtocolViolation));
663 webrtc_data_channel_->OnTransportChannelClosed(error);
664 provider_.reset(nullptr);
665 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kClosed,
666 webrtc_data_channel_->state(), kDefaultTimeout);
667 EXPECT_FALSE(webrtc_data_channel_->error().ok());
668 EXPECT_EQ(webrtc::RTCErrorType::OPERATION_ERROR_WITH_DATA,
669 webrtc_data_channel_->error().type());
670 EXPECT_EQ(webrtc::RTCErrorDetailType::SCTP_FAILURE,
671 webrtc_data_channel_->error().error_detail());
672 EXPECT_EQ(
673 static_cast<uint16_t>(cricket::SctpErrorCauseCode::kProtocolViolation),
674 webrtc_data_channel_->error().sctp_cause_code());
675}
676
Mirko Bonadei6a489f22019-04-09 13:11:12677class SctpSidAllocatorTest : public ::testing::Test {
deadbeefab9b2d12015-10-14 18:33:11678 protected:
679 SctpSidAllocator allocator_;
680};
681
682// Verifies that an even SCTP id is allocated for SSL_CLIENT and an odd id for
683// SSL_SERVER.
684TEST_F(SctpSidAllocatorTest, SctpIdAllocationBasedOnRole) {
685 int id;
686 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &id));
687 EXPECT_EQ(1, id);
688 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &id));
689 EXPECT_EQ(0, id);
690 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &id));
691 EXPECT_EQ(3, id);
692 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &id));
693 EXPECT_EQ(2, id);
694}
695
696// Verifies that SCTP ids of existing DataChannels are not reused.
697TEST_F(SctpSidAllocatorTest, SctpIdAllocationNoReuse) {
698 int old_id = 1;
699 EXPECT_TRUE(allocator_.ReserveSid(old_id));
700
701 int new_id;
702 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &new_id));
703 EXPECT_NE(old_id, new_id);
704
705 old_id = 0;
706 EXPECT_TRUE(allocator_.ReserveSid(old_id));
707 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &new_id));
708 EXPECT_NE(old_id, new_id);
709}
710
711// Verifies that SCTP ids of removed DataChannels can be reused.
712TEST_F(SctpSidAllocatorTest, SctpIdReusedForRemovedDataChannel) {
713 int odd_id = 1;
714 int even_id = 0;
715 EXPECT_TRUE(allocator_.ReserveSid(odd_id));
716 EXPECT_TRUE(allocator_.ReserveSid(even_id));
717
718 int allocated_id = -1;
719 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
720 EXPECT_EQ(odd_id + 2, allocated_id);
721
722 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
723 EXPECT_EQ(even_id + 2, allocated_id);
724
725 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
726 EXPECT_EQ(odd_id + 4, allocated_id);
727
728 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
729 EXPECT_EQ(even_id + 4, allocated_id);
730
731 allocator_.ReleaseSid(odd_id);
732 allocator_.ReleaseSid(even_id);
733
734 // Verifies that removed ids are reused.
735 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
736 EXPECT_EQ(odd_id, allocated_id);
737
738 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
739 EXPECT_EQ(even_id, allocated_id);
740
741 // Verifies that used higher ids are not reused.
742 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
743 EXPECT_EQ(odd_id + 6, allocated_id);
744
745 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
746 EXPECT_EQ(even_id + 6, allocated_id);
747}