Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(792)

Unified Diff: webrtc/media/sctp/sctptransport_unittest.cc

Issue 2564333002: Reland of: Separating SCTP code from BaseChannel/MediaChannel. (Closed)
Patch Set: Merge with master. Created 3 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/media/sctp/sctptransport.cc ('k') | webrtc/media/sctp/sctptransportinternal.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/media/sctp/sctptransport_unittest.cc
diff --git a/webrtc/media/sctp/sctptransport_unittest.cc b/webrtc/media/sctp/sctptransport_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..42e4dc646f37f1a646bcb101b727bf901df01682
--- /dev/null
+++ b/webrtc/media/sctp/sctptransport_unittest.cc
@@ -0,0 +1,563 @@
+/*
+ * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <errno.h>
+#include <stdarg.h>
+#include <stdio.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "webrtc/base/bind.h"
+#include "webrtc/base/copyonwritebuffer.h"
+#include "webrtc/base/criticalsection.h"
+#include "webrtc/base/gunit.h"
+#include "webrtc/base/helpers.h"
+#include "webrtc/base/ssladapter.h"
+#include "webrtc/base/thread.h"
+#include "webrtc/media/sctp/sctptransport.h"
+#include "webrtc/p2p/base/faketransportcontroller.h"
+
+namespace {
+static const int kDefaultTimeout = 10000; // 10 seconds.
+// Use ports other than the default 5000 for testing.
+static const int kTransport1Port = 5001;
+static const int kTransport2Port = 5002;
+}
+
+namespace cricket {
+
+// This is essentially a buffer to hold recieved data. It stores only the last
+// received data. Calling OnDataReceived twice overwrites old data with the
+// newer one.
+// TODO(ldixon): Implement constraints, and allow new data to be added to old
+// instead of replacing it.
+class SctpFakeDataReceiver : public sigslot::has_slots<> {
+ public:
+ SctpFakeDataReceiver() : received_(false) {}
+
+ void Clear() {
+ received_ = false;
+ last_data_ = "";
+ last_params_ = ReceiveDataParams();
+ }
+
+ virtual void OnDataReceived(const ReceiveDataParams& params,
+ const rtc::CopyOnWriteBuffer& data) {
+ received_ = true;
+ last_data_ = std::string(data.data<char>(), data.size());
+ last_params_ = params;
+ }
+
+ bool received() const { return received_; }
+ std::string last_data() const { return last_data_; }
+ ReceiveDataParams last_params() const { return last_params_; }
+
+ private:
+ bool received_;
+ std::string last_data_;
+ ReceiveDataParams last_params_;
+};
+
+class SignalReadyToSendObserver : public sigslot::has_slots<> {
+ public:
+ SignalReadyToSendObserver() : signaled_(false) {}
+
+ void OnSignaled() { signaled_ = true; }
+
+ bool IsSignaled() { return signaled_; }
+
+ private:
+ bool signaled_;
+};
+
+class SignalTransportClosedObserver : public sigslot::has_slots<> {
+ public:
+ SignalTransportClosedObserver() {}
+ void BindSelf(SctpTransport* transport) {
+ transport->SignalStreamClosedRemotely.connect(
+ this, &SignalTransportClosedObserver::OnStreamClosed);
+ }
+ void OnStreamClosed(int stream) { streams_.push_back(stream); }
+
+ int StreamCloseCount(int stream) {
+ return std::count(streams_.begin(), streams_.end(), stream);
+ }
+
+ bool WasStreamClosed(int stream) {
+ return std::find(streams_.begin(), streams_.end(), stream) !=
+ streams_.end();
+ }
+
+ private:
+ std::vector<int> streams_;
+};
+
+class SignalTransportClosedReopener : public sigslot::has_slots<> {
+ public:
+ SignalTransportClosedReopener(SctpTransport* transport, SctpTransport* peer)
+ : transport_(transport), peer_(peer) {}
+
+ void OnStreamClosed(int stream) {
+ transport_->OpenStream(stream);
+ peer_->OpenStream(stream);
+ streams_.push_back(stream);
+ }
+
+ int StreamCloseCount(int stream) {
+ return std::count(streams_.begin(), streams_.end(), stream);
+ }
+
+ private:
+ SctpTransport* transport_;
+ SctpTransport* peer_;
+ std::vector<int> streams_;
+};
+
+// SCTP Data Engine testing framework.
+class SctpTransportTest : public testing::Test, public sigslot::has_slots<> {
+ protected:
+ // usrsctp uses the NSS random number generator on non-Android platforms,
+ // so we need to initialize SSL.
+ static void SetUpTestCase() {}
+
+ void SetupConnectedTransportsWithTwoStreams() {
+ fake_dtls1_.reset(new FakeTransportChannel("fake dtls 1", 0));
+ fake_dtls2_.reset(new FakeTransportChannel("fake dtls 2", 0));
+ recv1_.reset(new SctpFakeDataReceiver());
+ recv2_.reset(new SctpFakeDataReceiver());
+ transport1_.reset(CreateTransport(fake_dtls1_.get(), recv1_.get()));
+ transport1_->set_debug_name_for_testing("transport1");
+ transport1_->SignalReadyToSendData.connect(
+ this, &SctpTransportTest::OnChan1ReadyToSend);
+ transport2_.reset(CreateTransport(fake_dtls2_.get(), recv2_.get()));
+ transport2_->set_debug_name_for_testing("transport2");
+ transport2_->SignalReadyToSendData.connect(
+ this, &SctpTransportTest::OnChan2ReadyToSend);
+ // Setup two connected transports ready to send and receive.
+ bool asymmetric = false;
+ fake_dtls1_->SetDestination(fake_dtls2_.get(), asymmetric);
+
+ LOG(LS_VERBOSE) << "Transport setup ----------------------------- ";
+ AddStream(1);
+ AddStream(2);
+
+ LOG(LS_VERBOSE) << "Connect the transports -----------------------------";
+ // Both transports need to have started (with matching ports) for an
+ // association to be formed.
+ transport1_->Start(kTransport1Port, kTransport2Port);
+ transport2_->Start(kTransport2Port, kTransport1Port);
+ }
+
+ bool AddStream(int sid) {
+ bool ret = true;
+ ret = ret && transport1_->OpenStream(sid);
+ ret = ret && transport2_->OpenStream(sid);
+ return ret;
+ }
+
+ SctpTransport* CreateTransport(FakeTransportChannel* fake_dtls,
+ SctpFakeDataReceiver* recv) {
+ SctpTransport* transport =
+ new SctpTransport(rtc::Thread::Current(), fake_dtls);
+ // When data is received, pass it to the SctpFakeDataReceiver.
+ transport->SignalDataReceived.connect(
+ recv, &SctpFakeDataReceiver::OnDataReceived);
+ return transport;
+ }
+
+ bool SendData(SctpTransport* chan,
+ int sid,
+ const std::string& msg,
+ SendDataResult* result) {
+ SendDataParams params;
+ params.sid = sid;
+
+ return chan->SendData(params, rtc::CopyOnWriteBuffer(&msg[0], msg.length()),
+ result);
+ }
+
+ bool ReceivedData(const SctpFakeDataReceiver* recv,
+ int sid,
+ const std::string& msg) {
+ return (recv->received() && recv->last_params().sid == sid &&
+ recv->last_data() == msg);
+ }
+
+ bool ProcessMessagesUntilIdle() {
+ rtc::Thread* thread = rtc::Thread::Current();
+ while (!thread->empty()) {
+ rtc::Message msg;
+ if (thread->Get(&msg, rtc::Thread::kForever)) {
+ thread->Dispatch(&msg);
+ }
+ }
+ return !thread->IsQuitting();
+ }
+
+ SctpTransport* transport1() { return transport1_.get(); }
+ SctpTransport* transport2() { return transport2_.get(); }
+ SctpFakeDataReceiver* receiver1() { return recv1_.get(); }
+ SctpFakeDataReceiver* receiver2() { return recv2_.get(); }
+ FakeTransportChannel* fake_dtls1() { return fake_dtls1_.get(); }
+ FakeTransportChannel* fake_dtls2() { return fake_dtls2_.get(); }
+
+ int transport1_ready_to_send_count() {
+ return transport1_ready_to_send_count_;
+ }
+ int transport2_ready_to_send_count() {
+ return transport2_ready_to_send_count_;
+ }
+
+ private:
+ std::unique_ptr<FakeTransportChannel> fake_dtls1_;
+ std::unique_ptr<FakeTransportChannel> fake_dtls2_;
+ std::unique_ptr<SctpFakeDataReceiver> recv1_;
+ std::unique_ptr<SctpFakeDataReceiver> recv2_;
+ std::unique_ptr<SctpTransport> transport1_;
+ std::unique_ptr<SctpTransport> transport2_;
+
+ int transport1_ready_to_send_count_ = 0;
+ int transport2_ready_to_send_count_ = 0;
+
+ void OnChan1ReadyToSend() { ++transport1_ready_to_send_count_; }
+ void OnChan2ReadyToSend() { ++transport2_ready_to_send_count_; }
+};
+
+// Test that data can be sent end-to-end when an SCTP transport starts with one
+// transport channel (which is unwritable), and then switches to another
+// channel. A common scenario due to how BUNDLE works.
+TEST_F(SctpTransportTest, SwitchTransportChannel) {
+ FakeTransportChannel black_hole("black hole", 0);
+ FakeTransportChannel fake_dtls1("fake dtls 1", 0);
+ FakeTransportChannel fake_dtls2("fake dtls 2", 0);
+ SctpFakeDataReceiver recv1;
+ SctpFakeDataReceiver recv2;
+
+ // Construct transport1 with the "black hole" channel.
+ std::unique_ptr<SctpTransport> transport1(
+ CreateTransport(&black_hole, &recv1));
+ std::unique_ptr<SctpTransport> transport2(
+ CreateTransport(&fake_dtls2, &recv2));
+
+ // Add a stream.
+ transport1->OpenStream(1);
+ transport2->OpenStream(1);
+
+ // Tell them both to start (though transport1_ is connected to black_hole).
+ transport1->Start(kTransport1Port, kTransport2Port);
+ transport2->Start(kTransport2Port, kTransport1Port);
+
+ // Switch transport1_ to the normal fake_dtls1_ channel.
+ transport1->SetTransportChannel(&fake_dtls1);
+
+ // Connect the two fake DTLS channels.
+ bool asymmetric = false;
+ fake_dtls1.SetDestination(&fake_dtls2, asymmetric);
+
+ // Make sure we end up able to send data.
+ SendDataResult result;
+ ASSERT_TRUE(SendData(transport1.get(), 1, "foo", &result));
+ ASSERT_TRUE(SendData(transport2.get(), 1, "bar", &result));
+ EXPECT_TRUE_WAIT(ReceivedData(&recv2, 1, "foo"), kDefaultTimeout);
+ EXPECT_TRUE_WAIT(ReceivedData(&recv1, 1, "bar"), kDefaultTimeout);
+}
+
+// Calling Start twice shouldn't do anything bad, if with the same parameters.
+TEST_F(SctpTransportTest, DuplicateStartCallsIgnored) {
+ SetupConnectedTransportsWithTwoStreams();
+ EXPECT_TRUE(transport1()->Start(kTransport1Port, kTransport2Port));
+
+ // Make sure we can still send/recv data.
+ SendDataResult result;
+ ASSERT_TRUE(SendData(transport1(), 1, "foo", &result));
+ ASSERT_TRUE(SendData(transport2(), 1, "bar", &result));
+ EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "foo"), kDefaultTimeout);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 1, "bar"), kDefaultTimeout);
+}
+
+// Calling Start a second time with a different port should fail.
+TEST_F(SctpTransportTest, CallingStartWithDifferentPortFails) {
+ SetupConnectedTransportsWithTwoStreams();
+ EXPECT_FALSE(transport1()->Start(kTransport1Port, 1234));
+ EXPECT_FALSE(transport1()->Start(1234, kTransport2Port));
+}
+
+// A value of -1 for the local/remote port should be treated as the default
+// (5000).
+TEST_F(SctpTransportTest, NegativeOnePortTreatedAsDefault) {
+ FakeTransportChannel fake_dtls1("fake dtls 1", 0);
+ FakeTransportChannel fake_dtls2("fake dtls 2", 0);
+ SctpFakeDataReceiver recv1;
+ SctpFakeDataReceiver recv2;
+ std::unique_ptr<SctpTransport> transport1(
+ CreateTransport(&fake_dtls1, &recv1));
+ std::unique_ptr<SctpTransport> transport2(
+ CreateTransport(&fake_dtls2, &recv2));
+
+ // Add a stream.
+ transport1->OpenStream(1);
+ transport2->OpenStream(1);
+
+ // Tell them both to start, giving one transport the default port and the
+ // other transport -1.
+ transport1->Start(kSctpDefaultPort, kSctpDefaultPort);
+ transport2->Start(-1, -1);
+
+ // Connect the two fake DTLS channels.
+ bool asymmetric = false;
+ fake_dtls1.SetDestination(&fake_dtls2, asymmetric);
+
+ // Make sure we end up able to send data.
+ SendDataResult result;
+ ASSERT_TRUE(SendData(transport1.get(), 1, "foo", &result));
+ ASSERT_TRUE(SendData(transport2.get(), 1, "bar", &result));
+ EXPECT_TRUE_WAIT(ReceivedData(&recv2, 1, "foo"), kDefaultTimeout);
+ EXPECT_TRUE_WAIT(ReceivedData(&recv1, 1, "bar"), kDefaultTimeout);
+}
+
+TEST_F(SctpTransportTest, OpenStreamWithAlreadyOpenedStreamFails) {
+ FakeTransportChannel fake_dtls("fake dtls", 0);
+ SctpFakeDataReceiver recv;
+ std::unique_ptr<SctpTransport> transport(CreateTransport(&fake_dtls, &recv));
+ EXPECT_TRUE(transport->OpenStream(1));
+ EXPECT_FALSE(transport->OpenStream(1));
+}
+
+TEST_F(SctpTransportTest, ResetStreamWithAlreadyResetStreamFails) {
+ FakeTransportChannel fake_dtls("fake dtls", 0);
+ SctpFakeDataReceiver recv;
+ std::unique_ptr<SctpTransport> transport(CreateTransport(&fake_dtls, &recv));
+ EXPECT_TRUE(transport->OpenStream(1));
+ EXPECT_TRUE(transport->ResetStream(1));
+ EXPECT_FALSE(transport->ResetStream(1));
+}
+
+// Test that SignalReadyToSendData is fired after Start has been called and the
+// DTLS channel is writable.
+TEST_F(SctpTransportTest, SignalReadyToSendDataAfterDtlsWritable) {
+ FakeTransportChannel fake_dtls("fake dtls", 0);
+ SctpFakeDataReceiver recv;
+ std::unique_ptr<SctpTransport> transport(CreateTransport(&fake_dtls, &recv));
+
+ SignalReadyToSendObserver signal_observer;
+ transport->SignalReadyToSendData.connect(
+ &signal_observer, &SignalReadyToSendObserver::OnSignaled);
+
+ transport->Start(kSctpDefaultPort, kSctpDefaultPort);
+ fake_dtls.SetWritable(true);
+ EXPECT_TRUE_WAIT(signal_observer.IsSignaled(), kDefaultTimeout);
+}
+
+// Test that after an SCTP socket's buffer is filled, SignalReadyToSendData
+// is fired after it begins to be drained.
+TEST_F(SctpTransportTest, SignalReadyToSendDataAfterBlocked) {
+ SetupConnectedTransportsWithTwoStreams();
+ // Wait for initial SCTP association to be formed.
+ EXPECT_EQ_WAIT(1, transport1_ready_to_send_count(), kDefaultTimeout);
+ // Make the fake transport unwritable so that messages pile up for the SCTP
+ // socket.
+ fake_dtls1()->SetWritable(false);
+ // Send messages until we get EWOULDBLOCK.
+ static const int kMaxMessages = 1024;
+ SendDataParams params;
+ params.sid = 1;
+ rtc::CopyOnWriteBuffer buf(1024);
+ memset(buf.data<uint8_t>(), 0, 1024);
+ SendDataResult result;
+ int message_count;
+ for (message_count = 0; message_count < kMaxMessages; ++message_count) {
+ if (!transport1()->SendData(params, buf, &result) && result == SDR_BLOCK) {
+ break;
+ }
+ }
+ ASSERT_NE(kMaxMessages, message_count)
+ << "Sent max number of messages without getting SDR_BLOCK?";
+ // Make sure the ready-to-send count hasn't changed.
+ EXPECT_EQ(1, transport1_ready_to_send_count());
+ // Make the transport writable again and expect a "SignalReadyToSendData" at
+ // some point.
+ fake_dtls1()->SetWritable(true);
+ EXPECT_EQ_WAIT(2, transport1_ready_to_send_count(), kDefaultTimeout);
+}
+
+TEST_F(SctpTransportTest, SendData) {
+ SetupConnectedTransportsWithTwoStreams();
+
+ SendDataResult result;
+ LOG(LS_VERBOSE)
+ << "transport1 sending: 'hello?' -----------------------------";
+ ASSERT_TRUE(SendData(transport1(), 1, "hello?", &result));
+ EXPECT_EQ(SDR_SUCCESS, result);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), kDefaultTimeout);
+ LOG(LS_VERBOSE) << "recv2.received=" << receiver2()->received()
+ << ", recv2.last_params.sid="
+ << receiver2()->last_params().sid
+ << ", recv2.last_params.timestamp="
+ << receiver2()->last_params().timestamp
+ << ", recv2.last_params.seq_num="
+ << receiver2()->last_params().seq_num
+ << ", recv2.last_data=" << receiver2()->last_data();
+
+ LOG(LS_VERBOSE)
+ << "transport2 sending: 'hi transport1' -----------------------------";
+ ASSERT_TRUE(SendData(transport2(), 2, "hi transport1", &result));
+ EXPECT_EQ(SDR_SUCCESS, result);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi transport1"),
+ kDefaultTimeout);
+ LOG(LS_VERBOSE) << "recv1.received=" << receiver1()->received()
+ << ", recv1.last_params.sid="
+ << receiver1()->last_params().sid
+ << ", recv1.last_params.timestamp="
+ << receiver1()->last_params().timestamp
+ << ", recv1.last_params.seq_num="
+ << receiver1()->last_params().seq_num
+ << ", recv1.last_data=" << receiver1()->last_data();
+}
+
+// Sends a lot of large messages at once and verifies SDR_BLOCK is returned.
+TEST_F(SctpTransportTest, SendDataBlocked) {
+ SetupConnectedTransportsWithTwoStreams();
+
+ SendDataResult result;
+ SendDataParams params;
+ params.sid = 1;
+
+ std::vector<char> buffer(1024 * 64, 0);
+
+ for (size_t i = 0; i < 100; ++i) {
+ transport1()->SendData(
+ params, rtc::CopyOnWriteBuffer(&buffer[0], buffer.size()), &result);
+ if (result == SDR_BLOCK)
+ break;
+ }
+
+ EXPECT_EQ(SDR_BLOCK, result);
+}
+
+// Trying to send data for a nonexistent stream should fail.
+TEST_F(SctpTransportTest, SendDataWithNonexistentStreamFails) {
+ SetupConnectedTransportsWithTwoStreams();
+ SendDataResult result;
+ EXPECT_FALSE(SendData(transport2(), 123, "some data", &result));
+ EXPECT_EQ(SDR_ERROR, result);
+}
+
+TEST_F(SctpTransportTest, ClosesRemoteStream) {
+ SetupConnectedTransportsWithTwoStreams();
+ SignalTransportClosedObserver transport1_sig_receiver,
+ transport2_sig_receiver;
+ transport1_sig_receiver.BindSelf(transport1());
+ transport2_sig_receiver.BindSelf(transport2());
+
+ SendDataResult result;
+ ASSERT_TRUE(SendData(transport1(), 1, "hello?", &result));
+ EXPECT_EQ(SDR_SUCCESS, result);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), kDefaultTimeout);
+ ASSERT_TRUE(SendData(transport2(), 2, "hi transport1", &result));
+ EXPECT_EQ(SDR_SUCCESS, result);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi transport1"),
+ kDefaultTimeout);
+
+ // Close transport 1. Transport 2 should notify us.
+ transport1()->ResetStream(1);
+ EXPECT_TRUE_WAIT(transport2_sig_receiver.WasStreamClosed(1), kDefaultTimeout);
+}
+
+TEST_F(SctpTransportTest, ClosesTwoRemoteStreams) {
+ SetupConnectedTransportsWithTwoStreams();
+ AddStream(3);
+ SignalTransportClosedObserver transport1_sig_receiver,
+ transport2_sig_receiver;
+ transport1_sig_receiver.BindSelf(transport1());
+ transport2_sig_receiver.BindSelf(transport2());
+
+ SendDataResult result;
+ ASSERT_TRUE(SendData(transport1(), 1, "hello?", &result));
+ EXPECT_EQ(SDR_SUCCESS, result);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), kDefaultTimeout);
+ ASSERT_TRUE(SendData(transport2(), 2, "hi transport1", &result));
+ EXPECT_EQ(SDR_SUCCESS, result);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi transport1"),
+ kDefaultTimeout);
+
+ // Close two streams on one side.
+ transport2()->ResetStream(2);
+ transport2()->ResetStream(3);
+ EXPECT_TRUE_WAIT(transport1_sig_receiver.WasStreamClosed(2), kDefaultTimeout);
+ EXPECT_TRUE_WAIT(transport1_sig_receiver.WasStreamClosed(3), kDefaultTimeout);
+}
+
+TEST_F(SctpTransportTest, ClosesStreamsOnBothSides) {
+ SetupConnectedTransportsWithTwoStreams();
+ AddStream(3);
+ AddStream(4);
+ SignalTransportClosedObserver transport1_sig_receiver,
+ transport2_sig_receiver;
+ transport1_sig_receiver.BindSelf(transport1());
+ transport2_sig_receiver.BindSelf(transport2());
+
+ SendDataResult result;
+ ASSERT_TRUE(SendData(transport1(), 1, "hello?", &result));
+ EXPECT_EQ(SDR_SUCCESS, result);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), kDefaultTimeout);
+ ASSERT_TRUE(SendData(transport2(), 2, "hi transport1", &result));
+ EXPECT_EQ(SDR_SUCCESS, result);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver1(), 2, "hi transport1"),
+ kDefaultTimeout);
+
+ // Close one stream on transport1(), while closing three streams on
+ // transport2(). They will conflict (only one side can close anything at a
+ // time, apparently). Test the resolution of the conflict.
+ transport1()->ResetStream(1);
+
+ transport2()->ResetStream(2);
+ transport2()->ResetStream(3);
+ transport2()->ResetStream(4);
+ EXPECT_TRUE_WAIT(transport2_sig_receiver.WasStreamClosed(1), kDefaultTimeout);
+ EXPECT_TRUE_WAIT(transport1_sig_receiver.WasStreamClosed(2), kDefaultTimeout);
+ EXPECT_TRUE_WAIT(transport1_sig_receiver.WasStreamClosed(3), kDefaultTimeout);
+ EXPECT_TRUE_WAIT(transport1_sig_receiver.WasStreamClosed(4), kDefaultTimeout);
+}
+
+TEST_F(SctpTransportTest, RefusesHighNumberedTransports) {
+ SetupConnectedTransportsWithTwoStreams();
+ EXPECT_TRUE(AddStream(kMaxSctpSid));
+ EXPECT_FALSE(AddStream(kMaxSctpSid + 1));
+}
+
+// Flaky, see webrtc:4453.
+TEST_F(SctpTransportTest, DISABLED_ReusesAStream) {
+ // Shut down transport 1, then open it up again for reuse.
+ SetupConnectedTransportsWithTwoStreams();
+ SendDataResult result;
+ SignalTransportClosedObserver transport2_sig_receiver;
+ transport2_sig_receiver.BindSelf(transport2());
+
+ ASSERT_TRUE(SendData(transport1(), 1, "hello?", &result));
+ EXPECT_EQ(SDR_SUCCESS, result);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hello?"), kDefaultTimeout);
+
+ transport1()->ResetStream(1);
+ EXPECT_TRUE_WAIT(transport2_sig_receiver.WasStreamClosed(1), kDefaultTimeout);
+ // Transport 1 is gone now.
+
+ // Create a new transport 1.
+ AddStream(1);
+ ASSERT_TRUE(SendData(transport1(), 1, "hi?", &result));
+ EXPECT_EQ(SDR_SUCCESS, result);
+ EXPECT_TRUE_WAIT(ReceivedData(receiver2(), 1, "hi?"), kDefaultTimeout);
+ transport1()->ResetStream(1);
+ EXPECT_TRUE_WAIT(transport2_sig_receiver.StreamCloseCount(1) == 2,
+ kDefaultTimeout);
+}
+
+} // namespace cricket
« no previous file with comments | « webrtc/media/sctp/sctptransport.cc ('k') | webrtc/media/sctp/sctptransportinternal.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698