blob: 11dfcc4aeed56c70ab10ae2224787fadd5d54f48 [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
Jonas Olssona4d87372019-07-05 17:08:3311#include "pc/data_channel.h"
12
Yves Gerey3e707812018-11-28 15:47:4913#include <string.h>
Jonas Olssona4d87372019-07-05 17:08:3314
kwibergd1fe2812016-04-27 13:47:2915#include <memory>
Steve Anton36b29d12017-10-30 16:57:4216#include <vector>
kwibergd1fe2812016-04-27 13:47:2917
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
wu@webrtc.org78187522013-10-07 23:32:0224using webrtc::DataChannel;
deadbeefab9b2d12015-10-14 18:33:1125using webrtc::SctpSidAllocator;
wu@webrtc.orgd64719d2013-08-01 00:00:0726
Taylor Brandstetter4cb5b642016-08-12 17:10:3127static constexpr int kDefaultTimeout = 10000;
28
sergeyu@chromium.orga23f0ca2013-11-13 22:48:5229class FakeDataChannelObserver : public webrtc::DataChannelObserver {
30 public:
jiayl@webrtc.org9f8164c2014-05-30 21:53:1731 FakeDataChannelObserver()
bemasc0edd50c2015-07-01 20:34:3332 : messages_received_(0),
33 on_state_change_count_(0),
34 on_buffered_amount_change_count_(0) {}
jiayl@webrtc.org5dc51fb2014-05-29 15:33:5435
Yves Gerey665174f2018-06-19 13:03:0536 void OnStateChange() { ++on_state_change_count_; }
jiayl@webrtc.org9f8164c2014-05-30 21:53:1737
Peter Boström0c4e06b2015-10-07 10:23:2138 void OnBufferedAmountChange(uint64_t previous_amount) {
bemasc0edd50c2015-07-01 20:34:3339 ++on_buffered_amount_change_count_;
40 }
41
Yves Gerey665174f2018-06-19 13:03:0542 void OnMessage(const webrtc::DataBuffer& buffer) { ++messages_received_; }
jiayl@webrtc.org5dc51fb2014-05-29 15:33:5443
Yves Gerey665174f2018-06-19 13:03:0544 size_t messages_received() const { return messages_received_; }
jiayl@webrtc.org5dc51fb2014-05-29 15:33:5445
Yves Gerey665174f2018-06-19 13:03:0546 void ResetOnStateChangeCount() { on_state_change_count_ = 0; }
jiayl@webrtc.org9f8164c2014-05-30 21:53:1747
bemasc0edd50c2015-07-01 20:34:3348 void ResetOnBufferedAmountChangeCount() {
49 on_buffered_amount_change_count_ = 0;
50 }
51
Yves Gerey665174f2018-06-19 13:03:0552 size_t on_state_change_count() const { return on_state_change_count_; }
jiayl@webrtc.org9f8164c2014-05-30 21:53:1753
bemasc0edd50c2015-07-01 20:34:3354 size_t on_buffered_amount_change_count() const {
55 return on_buffered_amount_change_count_;
56 }
57
jiayl@webrtc.org5dc51fb2014-05-29 15:33:5458 private:
59 size_t messages_received_;
jiayl@webrtc.org9f8164c2014-05-30 21:53:1760 size_t on_state_change_count_;
bemasc0edd50c2015-07-01 20:34:3361 size_t on_buffered_amount_change_count_;
sergeyu@chromium.orga23f0ca2013-11-13 22:48:5262};
63
Taylor Brandstettercdd05f02018-05-31 20:23:3264// TODO(deadbeef): The fact that these tests use a fake provider makes them not
65// too valuable. Should rewrite using the
66// peerconnection_datachannel_unittest.cc infrastructure.
Tomas Gunnarsson7d3cfbf2020-06-15 11:47:4267// TODO(bugs.webrtc.org/11547): Incorporate a dedicated network thread.
Mirko Bonadei6a489f22019-04-09 13:11:1268class SctpDataChannelTest : public ::testing::Test {
wu@webrtc.orgd64719d2013-08-01 00:00:0769 protected:
70 SctpDataChannelTest()
Taylor Brandstetter4cb5b642016-08-12 17:10:3171 : provider_(new FakeDataChannelProvider()),
72 webrtc_data_channel_(DataChannel::Create(provider_.get(),
73 cricket::DCT_SCTP,
74 "test",
Tomas Gunnarsson7d3cfbf2020-06-15 11:47:4275 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_;
buildbot@webrtc.orgd4e598d2014-07-29 17:36:5296 rtc::scoped_refptr<DataChannel> 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
Yves Gerey665174f2018-06-19 13:03:05104 void OnSignalOpened(DataChannel* data_channel) { ++opened_count_; }
hbos82ebe022016-11-14 09:41:09105
Yves Gerey665174f2018-06-19 13:03:05106 void OnSignalClosed(DataChannel* 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);
116 rtc::scoped_refptr<DataChannel> dc =
Tomas Gunnarsson7d3cfbf2020-06-15 11:47:42117 DataChannel::Create(provider_.get(), cricket::DCT_SCTP, "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);
Taylor Brandstetter4cb5b642016-08-12 17:10:31290 EXPECT_EQ(cricket::DMT_CONTROL, provider_->last_send_data_params().type);
291 EXPECT_EQ(provider_->last_send_data_params().ssrc,
Peter Boström0c4e06b2015-10-07 10:23:21292 static_cast<uint32_t>(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
Taylor Brandstetter4cb5b642016-08-12 17:10:31300 EXPECT_EQ(cricket::DMT_CONTROL, provider_->last_send_data_params().type);
301 EXPECT_EQ(provider_->last_send_data_params().ssrc,
Peter Boström0c4e06b2015-10-07 10:23:21302 static_cast<uint32_t>(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 Brandstetter4cb5b642016-08-12 17:10:31311 rtc::scoped_refptr<DataChannel> dc =
Tomas Gunnarsson7d3cfbf2020-06-15 11:47:42312 DataChannel::Create(provider_.get(), cricket::DCT_SCTP, "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 Brandstetter4cb5b642016-08-12 17:10:31325 rtc::scoped_refptr<DataChannel> dc =
Tomas Gunnarsson7d3cfbf2020-06-15 11:47:42326 DataChannel::Create(provider_.get(), cricket::DCT_SCTP, "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;
338 params.ssrc = init.id;
339 params.type = cricket::DMT_CONTROL;
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 Brandstetter4cb5b642016-08-12 17:10:31356 rtc::scoped_refptr<DataChannel> dc =
Tomas Gunnarsson7d3cfbf2020-06-15 11:47:42357 DataChannel::Create(provider_.get(), cricket::DCT_SCTP, "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;
364 params.ssrc = init.id;
365 params.type = cricket::DMT_TEXT;
366 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);
Taylor Brandstetter4cb5b642016-08-12 17:10:31386 EXPECT_EQ(cricket::DMT_CONTROL, provider_->last_send_data_params().type);
Lally Singh5c6c6e02015-05-29 15:52:39387}
388
389// Tests that close first makes sure all queued data gets sent.
390TEST_F(SctpDataChannelTest, QueuedCloseFlushes) {
391 webrtc::DataBuffer buffer("foo");
392
Taylor Brandstetter4cb5b642016-08-12 17:10:31393 provider_->set_send_blocked(true);
Lally Singh5c6c6e02015-05-29 15:52:39394 SetChannelReady();
395 EXPECT_EQ(webrtc::DataChannelInterface::kConnecting,
396 webrtc_data_channel_->state());
Taylor Brandstetter4cb5b642016-08-12 17:10:31397 provider_->set_send_blocked(false);
Lally Singh5c6c6e02015-05-29 15:52:39398 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen,
399 webrtc_data_channel_->state(), 1000);
Taylor Brandstetter4cb5b642016-08-12 17:10:31400 provider_->set_send_blocked(true);
Lally Singh5c6c6e02015-05-29 15:52:39401 webrtc_data_channel_->Send(buffer);
402 webrtc_data_channel_->Close();
Taylor Brandstetter4cb5b642016-08-12 17:10:31403 provider_->set_send_blocked(false);
Lally Singh5c6c6e02015-05-29 15:52:39404 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kClosed,
405 webrtc_data_channel_->state(), 1000);
Harald Alvestranddfbfb462019-12-08 04:55:43406 EXPECT_TRUE(webrtc_data_channel_->error().ok());
Taylor Brandstetter4cb5b642016-08-12 17:10:31407 EXPECT_EQ(cricket::DMT_TEXT, provider_->last_send_data_params().type);
Lally Singh5c6c6e02015-05-29 15:52:39408}
409
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52410// Tests that messages are sent with the right ssrc.
411TEST_F(SctpDataChannelTest, SendDataSsrc) {
412 webrtc_data_channel_->SetSctpSid(1);
413 SetChannelReady();
414 webrtc::DataBuffer buffer("data");
415 EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
Taylor Brandstetter4cb5b642016-08-12 17:10:31416 EXPECT_EQ(1U, provider_->last_send_data_params().ssrc);
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52417}
418
419// Tests that the incoming messages with wrong ssrcs are rejected.
420TEST_F(SctpDataChannelTest, ReceiveDataWithInvalidSsrc) {
421 webrtc_data_channel_->SetSctpSid(1);
422 SetChannelReady();
423
424 AddObserver();
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52425
426 cricket::ReceiveDataParams params;
427 params.ssrc = 0;
428 webrtc::DataBuffer buffer("abcd");
deadbeef953c2ce2017-01-09 22:53:41429 webrtc_data_channel_->OnDataReceived(params, buffer.data);
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54430
431 EXPECT_EQ(0U, observer_->messages_received());
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52432}
433
434// Tests that the incoming messages with right ssrcs are acceted.
435TEST_F(SctpDataChannelTest, ReceiveDataWithValidSsrc) {
436 webrtc_data_channel_->SetSctpSid(1);
437 SetChannelReady();
438
439 AddObserver();
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52440
441 cricket::ReceiveDataParams params;
442 params.ssrc = 1;
443 webrtc::DataBuffer buffer("abcd");
444
deadbeef953c2ce2017-01-09 22:53:41445 webrtc_data_channel_->OnDataReceived(params, buffer.data);
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54446 EXPECT_EQ(1U, observer_->messages_received());
sergeyu@chromium.orga23f0ca2013-11-13 22:48:52447}
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58448
449// Tests that no CONTROL message is sent if the datachannel is negotiated and
450// not created from an OPEN message.
451TEST_F(SctpDataChannelTest, NoMsgSentIfNegotiatedAndNotFromOpenMsg) {
452 webrtc::InternalDataChannelInit config;
453 config.id = 1;
454 config.negotiated = true;
455 config.open_handshake_role = webrtc::InternalDataChannelInit::kNone;
456
457 SetChannelReady();
Taylor Brandstetter4cb5b642016-08-12 17:10:31458 rtc::scoped_refptr<DataChannel> dc =
Tomas Gunnarsson7d3cfbf2020-06-15 11:47:42459 DataChannel::Create(provider_.get(), cricket::DCT_SCTP, "test1", config,
460 rtc::Thread::Current(), rtc::Thread::Current());
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58461
462 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
Taylor Brandstetter4cb5b642016-08-12 17:10:31463 EXPECT_EQ(0U, provider_->last_send_data_params().ssrc);
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58464}
465
hbos84ffdee2016-10-12 21:14:39466// Tests that DataChannel::messages_received() and DataChannel::bytes_received()
467// are correct, receiving data both while not open and while open.
468TEST_F(SctpDataChannelTest, VerifyMessagesAndBytesReceived) {
469 AddObserver();
470 std::vector<webrtc::DataBuffer> buffers({
Jonas Olssona4d87372019-07-05 17:08:33471 webrtc::DataBuffer("message 1"),
472 webrtc::DataBuffer("msg 2"),
473 webrtc::DataBuffer("message three"),
474 webrtc::DataBuffer("quadra message"),
Yves Gerey665174f2018-06-19 13:03:05475 webrtc::DataBuffer("fifthmsg"),
476 webrtc::DataBuffer("message of the beast"),
hbos84ffdee2016-10-12 21:14:39477 });
478
479 webrtc_data_channel_->SetSctpSid(1);
480 cricket::ReceiveDataParams params;
481 params.ssrc = 1;
482
483 // Default values.
484 EXPECT_EQ(0U, webrtc_data_channel_->messages_received());
485 EXPECT_EQ(0U, webrtc_data_channel_->bytes_received());
486
487 // Receive three buffers while data channel isn't open.
deadbeef953c2ce2017-01-09 22:53:41488 webrtc_data_channel_->OnDataReceived(params, buffers[0].data);
489 webrtc_data_channel_->OnDataReceived(params, buffers[1].data);
490 webrtc_data_channel_->OnDataReceived(params, buffers[2].data);
hbos84ffdee2016-10-12 21:14:39491 EXPECT_EQ(0U, observer_->messages_received());
492 EXPECT_EQ(0U, webrtc_data_channel_->messages_received());
493 EXPECT_EQ(0U, webrtc_data_channel_->bytes_received());
494
495 // Open channel and make sure everything was received.
496 SetChannelReady();
497 size_t bytes_received =
498 buffers[0].size() + buffers[1].size() + buffers[2].size();
499 EXPECT_EQ(3U, observer_->messages_received());
500 EXPECT_EQ(3U, webrtc_data_channel_->messages_received());
501 EXPECT_EQ(bytes_received, webrtc_data_channel_->bytes_received());
502
503 // Receive three buffers while open.
deadbeef953c2ce2017-01-09 22:53:41504 webrtc_data_channel_->OnDataReceived(params, buffers[3].data);
505 webrtc_data_channel_->OnDataReceived(params, buffers[4].data);
506 webrtc_data_channel_->OnDataReceived(params, buffers[5].data);
hbos84ffdee2016-10-12 21:14:39507 bytes_received += buffers[3].size() + buffers[4].size() + buffers[5].size();
508 EXPECT_EQ(6U, observer_->messages_received());
509 EXPECT_EQ(6U, webrtc_data_channel_->messages_received());
510 EXPECT_EQ(bytes_received, webrtc_data_channel_->bytes_received());
511}
512
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58513// Tests that OPEN_ACK message is sent if the datachannel is created from an
514// OPEN message.
515TEST_F(SctpDataChannelTest, OpenAckSentIfCreatedFromOpenMessage) {
516 webrtc::InternalDataChannelInit config;
517 config.id = 1;
518 config.negotiated = true;
519 config.open_handshake_role = webrtc::InternalDataChannelInit::kAcker;
520
521 SetChannelReady();
Taylor Brandstetter4cb5b642016-08-12 17:10:31522 rtc::scoped_refptr<DataChannel> dc =
Tomas Gunnarsson7d3cfbf2020-06-15 11:47:42523 DataChannel::Create(provider_.get(), cricket::DCT_SCTP, "test1", config,
524 rtc::Thread::Current(), rtc::Thread::Current());
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58525
526 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kOpen, dc->state(), 1000);
527
528 EXPECT_EQ(static_cast<unsigned int>(config.id),
Taylor Brandstetter4cb5b642016-08-12 17:10:31529 provider_->last_send_data_params().ssrc);
530 EXPECT_EQ(cricket::DMT_CONTROL, provider_->last_send_data_params().type);
henrika@webrtc.orgaebb1ad2014-01-14 10:00:58531}
532
533// Tests the OPEN_ACK role assigned by InternalDataChannelInit.
534TEST_F(SctpDataChannelTest, OpenAckRoleInitialization) {
535 webrtc::InternalDataChannelInit init;
536 EXPECT_EQ(webrtc::InternalDataChannelInit::kOpener, init.open_handshake_role);
537 EXPECT_FALSE(init.negotiated);
538
539 webrtc::DataChannelInit base;
540 base.negotiated = true;
541 webrtc::InternalDataChannelInit init2(base);
542 EXPECT_EQ(webrtc::InternalDataChannelInit::kNone, init2.open_handshake_role);
543}
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54544
545// Tests that the DataChannel is closed if the sending buffer is full.
546TEST_F(SctpDataChannelTest, ClosedWhenSendBufferFull) {
547 SetChannelReady();
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14548
jbaucheec21bd2016-03-20 13:15:43549 rtc::CopyOnWriteBuffer buffer(1024);
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06550 memset(buffer.data(), 0, buffer.size());
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14551
552 webrtc::DataBuffer packet(buffer, true);
Taylor Brandstetter4cb5b642016-08-12 17:10:31553 provider_->set_send_blocked(true);
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54554
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14555 for (size_t i = 0; i < 16 * 1024 + 1; ++i) {
556 EXPECT_TRUE(webrtc_data_channel_->Send(packet));
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54557 }
558
Lally Singh5c6c6e02015-05-29 15:52:39559 EXPECT_TRUE(
560 webrtc::DataChannelInterface::kClosed == webrtc_data_channel_->state() ||
561 webrtc::DataChannelInterface::kClosing == webrtc_data_channel_->state());
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54562}
563
564// Tests that the DataChannel is closed on transport errors.
565TEST_F(SctpDataChannelTest, ClosedOnTransportError) {
566 SetChannelReady();
567 webrtc::DataBuffer buffer("abcd");
Taylor Brandstetter4cb5b642016-08-12 17:10:31568 provider_->set_transport_error();
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54569
570 EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
571
572 EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
573 webrtc_data_channel_->state());
Harald Alvestranddfbfb462019-12-08 04:55:43574 EXPECT_FALSE(webrtc_data_channel_->error().ok());
575 EXPECT_EQ(webrtc::RTCErrorType::NETWORK_ERROR,
576 webrtc_data_channel_->error().type());
577 EXPECT_EQ(webrtc::RTCErrorDetailType::NONE,
578 webrtc_data_channel_->error().error_detail());
jiayl@webrtc.org5dc51fb2014-05-29 15:33:54579}
jiayl@webrtc.org9f8164c2014-05-30 21:53:17580
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14581// Tests that the DataChannel is closed if the received buffer is full.
582TEST_F(SctpDataChannelTest, ClosedWhenReceivedBufferFull) {
583 SetChannelReady();
jbaucheec21bd2016-03-20 13:15:43584 rtc::CopyOnWriteBuffer buffer(1024);
kwiberg@webrtc.orgeebcab52015-03-24 09:19:06585 memset(buffer.data(), 0, buffer.size());
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14586
587 cricket::ReceiveDataParams params;
588 params.ssrc = 0;
589
590 // Receiving data without having an observer will overflow the buffer.
591 for (size_t i = 0; i < 16 * 1024 + 1; ++i) {
deadbeef953c2ce2017-01-09 22:53:41592 webrtc_data_channel_->OnDataReceived(params, buffer);
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14593 }
594 EXPECT_EQ(webrtc::DataChannelInterface::kClosed,
595 webrtc_data_channel_->state());
Harald Alvestranddfbfb462019-12-08 04:55:43596 EXPECT_FALSE(webrtc_data_channel_->error().ok());
597 EXPECT_EQ(webrtc::RTCErrorType::RESOURCE_EXHAUSTED,
598 webrtc_data_channel_->error().type());
599 EXPECT_EQ(webrtc::RTCErrorDetailType::NONE,
600 webrtc_data_channel_->error().error_detail());
jiayl@webrtc.orgb43c99d2014-06-20 17:11:14601}
jiayl@webrtc.org3edbaaf2014-07-18 23:57:50602
603// Tests that sending empty data returns no error and keeps the channel open.
604TEST_F(SctpDataChannelTest, SendEmptyData) {
605 webrtc_data_channel_->SetSctpSid(1);
606 SetChannelReady();
Yves Gerey665174f2018-06-19 13:03:05607 EXPECT_EQ(webrtc::DataChannelInterface::kOpen, webrtc_data_channel_->state());
jiayl@webrtc.org3edbaaf2014-07-18 23:57:50608
609 webrtc::DataBuffer buffer("");
610 EXPECT_TRUE(webrtc_data_channel_->Send(buffer));
Yves Gerey665174f2018-06-19 13:03:05611 EXPECT_EQ(webrtc::DataChannelInterface::kOpen, webrtc_data_channel_->state());
jiayl@webrtc.org3edbaaf2014-07-18 23:57:50612}
bemasc@webrtc.org9b5467e2014-12-04 23:16:52613
614// Tests that a channel can be closed without being opened or assigned an sid.
615TEST_F(SctpDataChannelTest, NeverOpened) {
Taylor Brandstetter4cb5b642016-08-12 17:10:31616 provider_->set_transport_available(true);
bemasc@webrtc.org9b5467e2014-12-04 23:16:52617 webrtc_data_channel_->OnTransportChannelCreated();
618 webrtc_data_channel_->Close();
619}
deadbeefab9b2d12015-10-14 18:33:11620
Taylor Brandstetter4cb5b642016-08-12 17:10:31621// Test that the data channel goes to the "closed" state (and doesn't crash)
622// when its transport goes away, even while data is buffered.
623TEST_F(SctpDataChannelTest, TransportDestroyedWhileDataBuffered) {
624 SetChannelReady();
625
626 rtc::CopyOnWriteBuffer buffer(1024);
627 memset(buffer.data(), 0, buffer.size());
628 webrtc::DataBuffer packet(buffer, true);
629
630 // Send a packet while sending is blocked so it ends up buffered.
631 provider_->set_send_blocked(true);
632 EXPECT_TRUE(webrtc_data_channel_->Send(packet));
633
Harald Alvestrand408cb4b2019-11-16 11:09:08634 // Tell the data channel that its transport is being destroyed.
Taylor Brandstetter4cb5b642016-08-12 17:10:31635 // It should then stop using the transport (allowing us to delete it) and
636 // transition to the "closed" state.
Harald Alvestrand408cb4b2019-11-16 11:09:08637 webrtc_data_channel_->OnTransportChannelClosed();
Taylor Brandstetter4cb5b642016-08-12 17:10:31638 provider_.reset(nullptr);
639 EXPECT_EQ_WAIT(webrtc::DataChannelInterface::kClosed,
640 webrtc_data_channel_->state(), kDefaultTimeout);
Harald Alvestranddfbfb462019-12-08 04:55:43641 EXPECT_FALSE(webrtc_data_channel_->error().ok());
Harald Alvestrand37e42be2020-05-12 10:59:02642 EXPECT_EQ(webrtc::RTCErrorType::OPERATION_ERROR_WITH_DATA,
Harald Alvestranddfbfb462019-12-08 04:55:43643 webrtc_data_channel_->error().type());
Harald Alvestrand37e42be2020-05-12 10:59:02644 EXPECT_EQ(webrtc::RTCErrorDetailType::SCTP_FAILURE,
Harald Alvestranddfbfb462019-12-08 04:55:43645 webrtc_data_channel_->error().error_detail());
Taylor Brandstetter4cb5b642016-08-12 17:10:31646}
647
Mirko Bonadei6a489f22019-04-09 13:11:12648class SctpSidAllocatorTest : public ::testing::Test {
deadbeefab9b2d12015-10-14 18:33:11649 protected:
650 SctpSidAllocator allocator_;
651};
652
653// Verifies that an even SCTP id is allocated for SSL_CLIENT and an odd id for
654// SSL_SERVER.
655TEST_F(SctpSidAllocatorTest, SctpIdAllocationBasedOnRole) {
656 int id;
657 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &id));
658 EXPECT_EQ(1, id);
659 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &id));
660 EXPECT_EQ(0, id);
661 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &id));
662 EXPECT_EQ(3, id);
663 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &id));
664 EXPECT_EQ(2, id);
665}
666
667// Verifies that SCTP ids of existing DataChannels are not reused.
668TEST_F(SctpSidAllocatorTest, SctpIdAllocationNoReuse) {
669 int old_id = 1;
670 EXPECT_TRUE(allocator_.ReserveSid(old_id));
671
672 int new_id;
673 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &new_id));
674 EXPECT_NE(old_id, new_id);
675
676 old_id = 0;
677 EXPECT_TRUE(allocator_.ReserveSid(old_id));
678 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &new_id));
679 EXPECT_NE(old_id, new_id);
680}
681
682// Verifies that SCTP ids of removed DataChannels can be reused.
683TEST_F(SctpSidAllocatorTest, SctpIdReusedForRemovedDataChannel) {
684 int odd_id = 1;
685 int even_id = 0;
686 EXPECT_TRUE(allocator_.ReserveSid(odd_id));
687 EXPECT_TRUE(allocator_.ReserveSid(even_id));
688
689 int allocated_id = -1;
690 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
691 EXPECT_EQ(odd_id + 2, allocated_id);
692
693 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
694 EXPECT_EQ(even_id + 2, allocated_id);
695
696 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
697 EXPECT_EQ(odd_id + 4, allocated_id);
698
699 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
700 EXPECT_EQ(even_id + 4, allocated_id);
701
702 allocator_.ReleaseSid(odd_id);
703 allocator_.ReleaseSid(even_id);
704
705 // Verifies that removed ids are reused.
706 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
707 EXPECT_EQ(odd_id, allocated_id);
708
709 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
710 EXPECT_EQ(even_id, allocated_id);
711
712 // Verifies that used higher ids are not reused.
713 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_SERVER, &allocated_id));
714 EXPECT_EQ(odd_id + 6, allocated_id);
715
716 EXPECT_TRUE(allocator_.AllocateSid(rtc::SSL_CLIENT, &allocated_id));
717 EXPECT_EQ(even_id + 6, allocated_id);
718}