dcsctp: Refactor socket test to allow recreation of the sockets.
This will be useful in future socket handover tests.
Bug: webrtc:13154
Change-Id: Ia789ae971edd9d2832be088f2f8f7dd50c9ce52d
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/231222
Reviewed-by: Victor Boivie <boivie@webrtc.org>
Commit-Queue: Sergey Sukhanov <sergeysu@webrtc.org>
Cr-Commit-Position: refs/heads/main@{#34931}
diff --git a/net/dcsctp/common/internal_types.h b/net/dcsctp/common/internal_types.h
index 3bbc05e..e7dabf3 100644
--- a/net/dcsctp/common/internal_types.h
+++ b/net/dcsctp/common/internal_types.h
@@ -10,6 +10,7 @@
#ifndef NET_DCSCTP_COMMON_INTERNAL_TYPES_H_
#define NET_DCSCTP_COMMON_INTERNAL_TYPES_H_
+#include <functional>
#include <utility>
#include "net/dcsctp/public/strong_alias.h"
diff --git a/net/dcsctp/socket/dcsctp_socket_test.cc b/net/dcsctp/socket/dcsctp_socket_test.cc
index c0d7725..5f99cc9 100644
--- a/net/dcsctp/socket/dcsctp_socket_test.cc
+++ b/net/dcsctp/socket/dcsctp_socket_test.cc
@@ -254,8 +254,10 @@
: options_(MakeOptionsForTest(enable_message_interleaving)),
cb_a_("A"),
cb_z_("Z"),
- sock_a_("A", cb_a_, GetPacketObserver("A"), options_),
- sock_z_("Z", cb_z_, GetPacketObserver("Z"), options_) {}
+ sock_a_(std::make_unique<DcSctpSocket>(
+ "A", cb_a_, GetPacketObserver("A"), options_)),
+ sock_z_(std::make_unique<DcSctpSocket>(
+ "Z", cb_z_, GetPacketObserver("Z"), options_)) {}
void AdvanceTime(DurationMs duration) {
cb_a_.AdvanceTime(duration);
@@ -293,8 +295,8 @@
}
void RunTimers() {
- RunTimers(cb_a_, sock_a_);
- RunTimers(cb_z_, sock_z_);
+ RunTimers(cb_a_, *sock_a_);
+ RunTimers(cb_z_, *sock_z_);
}
// Calls Connect() on `sock_a_` and make the connection established.
@@ -302,22 +304,22 @@
EXPECT_CALL(cb_a_, OnConnected).Times(1);
EXPECT_CALL(cb_z_, OnConnected).Times(1);
- sock_a_.Connect();
+ sock_a_->Connect();
// Z reads INIT, INIT_ACK, COOKIE_ECHO, COOKIE_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
- EXPECT_EQ(sock_a_.state(), SocketState::kConnected);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnected);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
}
const DcSctpOptions options_;
testing::NiceMock<MockDcSctpSocketCallbacks> cb_a_;
testing::NiceMock<MockDcSctpSocketCallbacks> cb_z_;
- DcSctpSocket sock_a_;
- DcSctpSocket sock_z_;
+ std::unique_ptr<DcSctpSocket> sock_a_;
+ std::unique_ptr<DcSctpSocket> sock_z_;
};
TEST_F(DcSctpSocketTest, EstablishConnection) {
@@ -326,18 +328,18 @@
EXPECT_CALL(cb_a_, OnConnectionRestarted).Times(0);
EXPECT_CALL(cb_z_, OnConnectionRestarted).Times(0);
- sock_a_.Connect();
+ sock_a_->Connect();
// Z reads INIT, produces INIT_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads INIT_ACK, produces COOKIE_ECHO
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Z reads COOKIE_ECHO, produces COOKIE_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads COOKIE_ACK.
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
- EXPECT_EQ(sock_a_.state(), SocketState::kConnected);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnected);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
}
TEST_F(DcSctpSocketTest, EstablishConnectionWithSetupCollision) {
@@ -345,53 +347,53 @@
EXPECT_CALL(cb_z_, OnConnected).Times(1);
EXPECT_CALL(cb_a_, OnConnectionRestarted).Times(0);
EXPECT_CALL(cb_z_, OnConnectionRestarted).Times(0);
- sock_a_.Connect();
- sock_z_.Connect();
+ sock_a_->Connect();
+ sock_z_->Connect();
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
- EXPECT_EQ(sock_a_.state(), SocketState::kConnected);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnected);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
}
TEST_F(DcSctpSocketTest, ShuttingDownWhileEstablishingConnection) {
EXPECT_CALL(cb_a_, OnConnected).Times(0);
EXPECT_CALL(cb_z_, OnConnected).Times(1);
- sock_a_.Connect();
+ sock_a_->Connect();
// Z reads INIT, produces INIT_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads INIT_ACK, produces COOKIE_ECHO
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Z reads COOKIE_ECHO, produces COOKIE_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// Drop COOKIE_ACK, just to more easily verify shutdown protocol.
cb_z_.ConsumeSentPacket();
// As Socket A has received INIT_ACK, it has a TCB and is connected, while
// Socket Z needs to receive COOKIE_ECHO to get there. Socket A still has
// timers running at this point.
- EXPECT_EQ(sock_a_.state(), SocketState::kConnecting);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnecting);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
// Socket A is now shut down, which should make it stop those timers.
- sock_a_.Shutdown();
+ sock_a_->Shutdown();
EXPECT_CALL(cb_a_, OnClosed).Times(1);
EXPECT_CALL(cb_z_, OnClosed).Times(1);
// Z reads SHUTDOWN, produces SHUTDOWN_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads SHUTDOWN_ACK, produces SHUTDOWN_COMPLETE
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Z reads SHUTDOWN_COMPLETE.
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
EXPECT_TRUE(cb_a_.ConsumeSentPacket().empty());
EXPECT_TRUE(cb_z_.ConsumeSentPacket().empty());
- EXPECT_EQ(sock_a_.state(), SocketState::kClosed);
- EXPECT_EQ(sock_z_.state(), SocketState::kClosed);
+ EXPECT_EQ(sock_a_->state(), SocketState::kClosed);
+ EXPECT_EQ(sock_z_->state(), SocketState::kClosed);
}
TEST_F(DcSctpSocketTest, EstablishSimultaneousConnection) {
@@ -399,29 +401,29 @@
EXPECT_CALL(cb_z_, OnConnected).Times(1);
EXPECT_CALL(cb_a_, OnConnectionRestarted).Times(0);
EXPECT_CALL(cb_z_, OnConnectionRestarted).Times(0);
- sock_a_.Connect();
+ sock_a_->Connect();
// INIT isn't received by Z, as it wasn't ready yet.
cb_a_.ConsumeSentPacket();
- sock_z_.Connect();
+ sock_z_->Connect();
// A reads INIT, produces INIT_ACK
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Z reads INIT_ACK, sends COOKIE_ECHO
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads COOKIE_ECHO - establishes connection.
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
- EXPECT_EQ(sock_a_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnected);
// Proceed with the remaining packets.
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
- EXPECT_EQ(sock_a_.state(), SocketState::kConnected);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnected);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
}
TEST_F(DcSctpSocketTest, EstablishConnectionLostCookieAck) {
@@ -430,34 +432,34 @@
EXPECT_CALL(cb_a_, OnConnectionRestarted).Times(0);
EXPECT_CALL(cb_z_, OnConnectionRestarted).Times(0);
- sock_a_.Connect();
+ sock_a_->Connect();
// Z reads INIT, produces INIT_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads INIT_ACK, produces COOKIE_ECHO
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Z reads COOKIE_ECHO, produces COOKIE_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// COOKIE_ACK is lost.
cb_z_.ConsumeSentPacket();
- EXPECT_EQ(sock_a_.state(), SocketState::kConnecting);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnecting);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
// This will make A re-send the COOKIE_ECHO
AdvanceTime(DurationMs(options_.t1_cookie_timeout));
RunTimers();
// Z reads COOKIE_ECHO, produces COOKIE_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads COOKIE_ACK.
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
- EXPECT_EQ(sock_a_.state(), SocketState::kConnected);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnected);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
}
TEST_F(DcSctpSocketTest, ResendInitAndEstablishConnection) {
- sock_a_.Connect();
+ sock_a_->Connect();
// INIT is never received by Z.
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket init_packet,
SctpPacket::Parse(cb_a_.ConsumeSentPacket()));
@@ -467,20 +469,20 @@
RunTimers();
// Z reads INIT, produces INIT_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads INIT_ACK, produces COOKIE_ECHO
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Z reads COOKIE_ECHO, produces COOKIE_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads COOKIE_ACK.
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
- EXPECT_EQ(sock_a_.state(), SocketState::kConnected);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnected);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
}
TEST_F(DcSctpSocketTest, ResendingInitTooManyTimesAborts) {
- sock_a_.Connect();
+ sock_a_->Connect();
// INIT is never received by Z.
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket init_packet,
@@ -502,16 +504,16 @@
EXPECT_CALL(cb_a_, OnAborted).Times(1);
RunTimers();
- EXPECT_EQ(sock_a_.state(), SocketState::kClosed);
+ EXPECT_EQ(sock_a_->state(), SocketState::kClosed);
}
TEST_F(DcSctpSocketTest, ResendCookieEchoAndEstablishConnection) {
- sock_a_.Connect();
+ sock_a_->Connect();
// Z reads INIT, produces INIT_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads INIT_ACK, produces COOKIE_ECHO
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// COOKIE_ECHO is never received by Z.
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket init_packet,
@@ -522,21 +524,21 @@
RunTimers();
// Z reads COOKIE_ECHO, produces COOKIE_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads COOKIE_ACK.
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
- EXPECT_EQ(sock_a_.state(), SocketState::kConnected);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnected);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
}
TEST_F(DcSctpSocketTest, ResendingCookieEchoTooManyTimesAborts) {
- sock_a_.Connect();
+ sock_a_->Connect();
// Z reads INIT, produces INIT_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads INIT_ACK, produces COOKIE_ECHO
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// COOKIE_ECHO is never received by Z.
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket init_packet,
@@ -559,19 +561,19 @@
EXPECT_CALL(cb_a_, OnAborted).Times(1);
RunTimers();
- EXPECT_EQ(sock_a_.state(), SocketState::kClosed);
+ EXPECT_EQ(sock_a_->state(), SocketState::kClosed);
}
TEST_F(DcSctpSocketTest, DoesntSendMorePacketsUntilCookieAckHasBeenReceived) {
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53),
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53),
std::vector<uint8_t>(kLargeMessageSize)),
kSendOptions);
- sock_a_.Connect();
+ sock_a_->Connect();
// Z reads INIT, produces INIT_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads INIT_ACK, produces COOKIE_ECHO
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// COOKIE_ECHO is never received by Z.
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket cookie_echo_packet1,
@@ -609,14 +611,14 @@
RunTimers();
// Z reads COOKIE_ECHO, produces COOKIE_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads COOKIE_ACK.
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
- EXPECT_EQ(sock_a_.state(), SocketState::kConnected);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnected);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
EXPECT_THAT(cb_z_.ConsumeReceivedMessage()->payload(),
SizeIs(kLargeMessageSize));
}
@@ -626,26 +628,26 @@
RTC_LOG(LS_INFO) << "Shutting down";
- sock_a_.Shutdown();
+ sock_a_->Shutdown();
// Z reads SHUTDOWN, produces SHUTDOWN_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// A reads SHUTDOWN_ACK, produces SHUTDOWN_COMPLETE
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Z reads SHUTDOWN_COMPLETE.
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
- EXPECT_EQ(sock_a_.state(), SocketState::kClosed);
- EXPECT_EQ(sock_z_.state(), SocketState::kClosed);
+ EXPECT_EQ(sock_a_->state(), SocketState::kClosed);
+ EXPECT_EQ(sock_z_->state(), SocketState::kClosed);
}
TEST_F(DcSctpSocketTest, ShutdownTimerExpiresTooManyTimeClosesConnection) {
ConnectSockets();
- sock_a_.Shutdown();
+ sock_a_->Shutdown();
// Drop first SHUTDOWN packet.
cb_a_.ConsumeSentPacket();
- EXPECT_EQ(sock_a_.state(), SocketState::kShuttingDown);
+ EXPECT_EQ(sock_a_->state(), SocketState::kShuttingDown);
for (int i = 0; i < *options_.max_retransmissions; ++i) {
AdvanceTime(DurationMs(options_.rto_initial * (1 << i)));
@@ -662,7 +664,7 @@
EXPECT_CALL(cb_a_, OnAborted).Times(1);
RunTimers();
- EXPECT_EQ(sock_a_.state(), SocketState::kClosed);
+ EXPECT_EQ(sock_a_->state(), SocketState::kClosed);
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket packet,
SctpPacket::Parse(cb_a_.ConsumeSentPacket()));
EXPECT_EQ(packet.descriptors()[0].type, AbortChunk::kType);
@@ -670,21 +672,21 @@
}
TEST_F(DcSctpSocketTest, EstablishConnectionWhileSendingData) {
- sock_a_.Connect();
+ sock_a_->Connect();
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), kSendOptions);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), kSendOptions);
// Z reads INIT, produces INIT_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// // A reads INIT_ACK, produces COOKIE_ECHO
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// // Z reads COOKIE_ECHO, produces COOKIE_ACK
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// // A reads COOKIE_ACK.
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
- EXPECT_EQ(sock_a_.state(), SocketState::kConnected);
- EXPECT_EQ(sock_z_.state(), SocketState::kConnected);
+ EXPECT_EQ(sock_a_->state(), SocketState::kConnected);
+ EXPECT_EQ(sock_z_->state(), SocketState::kConnected);
absl::optional<DcSctpMessage> msg = cb_z_.ConsumeReceivedMessage();
ASSERT_TRUE(msg.has_value());
@@ -694,8 +696,8 @@
TEST_F(DcSctpSocketTest, SendMessageAfterEstablished) {
ConnectSockets();
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), kSendOptions);
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), kSendOptions);
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
absl::optional<DcSctpMessage> msg = cb_z_.ConsumeReceivedMessage();
ASSERT_TRUE(msg.has_value());
@@ -705,14 +707,14 @@
TEST_F(DcSctpSocketTest, TimeoutResendsPacket) {
ConnectSockets();
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), kSendOptions);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), kSendOptions);
cb_a_.ConsumeSentPacket();
RTC_LOG(LS_INFO) << "Advancing time";
AdvanceTime(options_.rto_initial);
RunTimers();
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
absl::optional<DcSctpMessage> msg = cb_z_.ConsumeReceivedMessage();
ASSERT_TRUE(msg.has_value());
@@ -723,15 +725,15 @@
ConnectSockets();
std::vector<uint8_t> payload(kLargeMessageSize);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), kSendOptions);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), kSendOptions);
// First DATA
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// Second DATA (lost)
cb_a_.ConsumeSentPacket();
// Retransmit and handle the rest
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
absl::optional<DcSctpMessage> msg = cb_z_.ConsumeReceivedMessage();
ASSERT_TRUE(msg.has_value());
@@ -743,12 +745,12 @@
ConnectSockets();
// Inject a HEARTBEAT chunk
- SctpPacket::Builder b(sock_a_.verification_tag(), DcSctpOptions());
+ SctpPacket::Builder b(sock_a_->verification_tag(), DcSctpOptions());
uint8_t info[] = {1, 2, 3, 4};
Parameters::Builder params_builder;
params_builder.Add(HeartbeatInfoParameter(info));
b.Add(HeartbeatRequestChunk(params_builder.Build()));
- sock_a_.ReceivePacket(b.Build());
+ sock_a_->ReceivePacket(b.Build());
// HEARTBEAT_ACK is sent as a reply. Capture it.
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket ack_packet,
@@ -782,8 +784,8 @@
EXPECT_THAT(hb.info()->info(), SizeIs(8));
// Feed it to Sock-z and expect a HEARTBEAT_ACK that will be propagated back.
- sock_z_.ReceivePacket(hb_packet_raw);
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(hb_packet_raw);
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
}
TEST_F(DcSctpSocketTest, CloseConnectionAfterTooManyLostHeartbeats) {
@@ -791,7 +793,7 @@
EXPECT_THAT(cb_a_.ConsumeSentPacket(), testing::IsEmpty());
// Force-close socket Z so that it doesn't interfere from now on.
- sock_z_.Close();
+ sock_z_->Close();
DurationMs time_to_next_hearbeat = options_.heartbeat_interval;
@@ -830,7 +832,7 @@
EXPECT_THAT(cb_a_.ConsumeSentPacket(), testing::IsEmpty());
// Force-close socket Z so that it doesn't interfere from now on.
- sock_z_.Close();
+ sock_z_->Close();
DurationMs time_to_next_hearbeat = options_.heartbeat_interval;
@@ -860,9 +862,9 @@
HeartbeatRequestChunk hb,
HeartbeatRequestChunk::Parse(hb_packet.descriptors()[0].data));
- SctpPacket::Builder b(sock_a_.verification_tag(), options_);
+ SctpPacket::Builder b(sock_a_->verification_tag(), options_);
b.Add(HeartbeatAckChunk(std::move(hb).extract_parameters()));
- sock_a_.ReceivePacket(b.Build());
+ sock_a_->ReceivePacket(b.Build());
// Should suffice as exceeding RTO - which will not fire.
EXPECT_CALL(cb_a_, OnAborted).Times(0);
@@ -883,27 +885,27 @@
TEST_F(DcSctpSocketTest, ResetStream) {
ConnectSockets();
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), {});
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), {});
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
absl::optional<DcSctpMessage> msg = cb_z_.ConsumeReceivedMessage();
ASSERT_TRUE(msg.has_value());
EXPECT_EQ(msg->stream_id(), StreamID(1));
// Handle SACK
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Reset the outgoing stream. This will directly send a RE-CONFIG.
- sock_a_.ResetStreams(std::vector<StreamID>({StreamID(1)}));
+ sock_a_->ResetStreams(std::vector<StreamID>({StreamID(1)}));
// Receiving the packet will trigger a callback, indicating that A has
// reset its stream. It will also send a RE-CONFIG with a response.
EXPECT_CALL(cb_z_, OnIncomingStreamsReset).Times(1);
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// Receiving a response will trigger a callback. Streams are now reset.
EXPECT_CALL(cb_a_, OnStreamsResetPerformed).Times(1);
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
}
TEST_F(DcSctpSocketTest, ResetStreamWillMakeChunksStartAtZeroSsn) {
@@ -911,19 +913,19 @@
std::vector<uint8_t> payload(options_.mtu - 100);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
auto packet1 = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet1, HasDataChunkWithSsn(SSN(0)));
- sock_z_.ReceivePacket(packet1);
+ sock_z_->ReceivePacket(packet1);
auto packet2 = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet2, HasDataChunkWithSsn(SSN(1)));
- sock_z_.ReceivePacket(packet2);
+ sock_z_->ReceivePacket(packet2);
// Handle SACK
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
absl::optional<DcSctpMessage> msg1 = cb_z_.ConsumeReceivedMessage();
ASSERT_TRUE(msg1.has_value());
@@ -934,26 +936,26 @@
EXPECT_EQ(msg2->stream_id(), StreamID(1));
// Reset the outgoing stream. This will directly send a RE-CONFIG.
- sock_a_.ResetStreams(std::vector<StreamID>({StreamID(1)}));
+ sock_a_->ResetStreams(std::vector<StreamID>({StreamID(1)}));
// RE-CONFIG, req
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// RE-CONFIG, resp
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
auto packet3 = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet3, HasDataChunkWithSsn(SSN(0)));
- sock_z_.ReceivePacket(packet3);
+ sock_z_->ReceivePacket(packet3);
auto packet4 = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet4, HasDataChunkWithSsn(SSN(1)));
- sock_z_.ReceivePacket(packet4);
+ sock_z_->ReceivePacket(packet4);
// Handle SACK
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
}
TEST_F(DcSctpSocketTest, ResetStreamWillOnlyResetTheRequestedStreams) {
@@ -962,34 +964,34 @@
std::vector<uint8_t> payload(options_.mtu - 100);
// Send two ordered messages on SID 1
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
auto packet1 = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet1, HasDataChunkWithStreamId(StreamID(1)));
EXPECT_THAT(packet1, HasDataChunkWithSsn(SSN(0)));
- sock_z_.ReceivePacket(packet1);
+ sock_z_->ReceivePacket(packet1);
auto packet2 = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet1, HasDataChunkWithStreamId(StreamID(1)));
EXPECT_THAT(packet2, HasDataChunkWithSsn(SSN(1)));
- sock_z_.ReceivePacket(packet2);
+ sock_z_->ReceivePacket(packet2);
// Handle SACK
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Do the same, for SID 3
- sock_a_.Send(DcSctpMessage(StreamID(3), PPID(53), payload), {});
- sock_a_.Send(DcSctpMessage(StreamID(3), PPID(53), payload), {});
+ sock_a_->Send(DcSctpMessage(StreamID(3), PPID(53), payload), {});
+ sock_a_->Send(DcSctpMessage(StreamID(3), PPID(53), payload), {});
auto packet3 = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet3, HasDataChunkWithStreamId(StreamID(3)));
EXPECT_THAT(packet3, HasDataChunkWithSsn(SSN(0)));
- sock_z_.ReceivePacket(packet3);
+ sock_z_->ReceivePacket(packet3);
auto packet4 = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet4, HasDataChunkWithStreamId(StreamID(3)));
EXPECT_THAT(packet4, HasDataChunkWithSsn(SSN(1)));
- sock_z_.ReceivePacket(packet4);
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(packet4);
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Receive all messages.
absl::optional<DcSctpMessage> msg1 = cb_z_.ConsumeReceivedMessage();
@@ -1009,29 +1011,29 @@
EXPECT_EQ(msg4->stream_id(), StreamID(3));
// Reset SID 1. This will directly send a RE-CONFIG.
- sock_a_.ResetStreams(std::vector<StreamID>({StreamID(3)}));
+ sock_a_->ResetStreams(std::vector<StreamID>({StreamID(3)}));
// RE-CONFIG, req
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// RE-CONFIG, resp
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Send a message on SID 1 and 3 - SID 1 should not be reset, but 3 should.
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), {});
- sock_a_.Send(DcSctpMessage(StreamID(3), PPID(53), payload), {});
+ sock_a_->Send(DcSctpMessage(StreamID(3), PPID(53), payload), {});
auto packet5 = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet5, HasDataChunkWithStreamId(StreamID(1)));
EXPECT_THAT(packet5, HasDataChunkWithSsn(SSN(2))); // Unchanged.
- sock_z_.ReceivePacket(packet5);
+ sock_z_->ReceivePacket(packet5);
auto packet6 = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet6, HasDataChunkWithStreamId(StreamID(3)));
EXPECT_THAT(packet6, HasDataChunkWithSsn(SSN(0))); // Reset.
- sock_z_.ReceivePacket(packet6);
+ sock_z_->ReceivePacket(packet6);
// Handle SACK
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
}
TEST_F(DcSctpSocketTest, OnePeerReconnects) {
@@ -1041,10 +1043,10 @@
// Let's be evil here - reconnect while a fragmented packet was about to be
// sent. The receiving side should get it in full.
std::vector<uint8_t> payload(kLargeMessageSize);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), kSendOptions);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), kSendOptions);
// First DATA
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// Create a new association, z2 - and don't use z anymore.
testing::NiceMock<MockDcSctpSocketCallbacks> cb_z2("Z2");
@@ -1054,7 +1056,7 @@
// Retransmit and handle the rest. As there will be some chunks in-flight that
// have the wrong verification tag, those will yield errors.
- ExchangeMessages(sock_a_, cb_a_, sock_z2, cb_z2);
+ ExchangeMessages(*sock_a_, cb_a_, sock_z2, cb_z2);
absl::optional<DcSctpMessage> msg = cb_z2.ConsumeReceivedMessage();
ASSERT_TRUE(msg.has_value());
@@ -1068,26 +1070,26 @@
SendOptions send_options;
send_options.max_retransmissions = 0;
std::vector<uint8_t> payload(options_.mtu - 100);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(51), payload), send_options);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(52), payload), send_options);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(51), payload), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(52), payload), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), send_options);
// First DATA
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// Second DATA (lost)
cb_a_.ConsumeSentPacket();
// Third DATA
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// Handle SACK for first DATA
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Handle delayed SACK for third DATA
AdvanceTime(options_.delayed_ack_max_timeout);
RunTimers();
// Handle SACK for second DATA
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
// Now the missing data chunk will be marked as nacked, but it might still be
// in-flight and the reported gap could be due to out-of-order delivery. So
@@ -1100,10 +1102,10 @@
// will trigger a FORWARD-TSN to be sent.
// FORWARD-TSN (third)
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// Which will trigger a SACK
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
absl::optional<DcSctpMessage> msg1 = cb_z_.ConsumeReceivedMessage();
ASSERT_TRUE(msg1.has_value());
@@ -1125,18 +1127,18 @@
send_options.max_retransmissions = 0;
std::vector<uint8_t> payload(options_.mtu * 2 - 100 /* margin */);
// Sending first message
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(51), payload), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(51), payload), send_options);
// Sending second message
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(52), payload), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(52), payload), send_options);
// Sending third message
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), send_options);
// Sending fourth message
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(54), payload), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(54), payload), send_options);
// First DATA, first fragment
std::vector<uint8_t> packet = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet, HasDataChunkWithPPID(PPID(51)));
- sock_z_.ReceivePacket(std::move(packet));
+ sock_z_->ReceivePacket(std::move(packet));
// First DATA, second fragment (lost)
packet = cb_a_.ConsumeSentPacket();
@@ -1145,7 +1147,7 @@
// Second DATA, first fragment
packet = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet, HasDataChunkWithPPID(PPID(52)));
- sock_z_.ReceivePacket(std::move(packet));
+ sock_z_->ReceivePacket(std::move(packet));
// Second DATA, second fragment (lost)
packet = cb_a_.ConsumeSentPacket();
@@ -1156,7 +1158,7 @@
packet = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet, HasDataChunkWithPPID(PPID(53)));
EXPECT_THAT(packet, HasDataChunkWithSsn(SSN(0)));
- sock_z_.ReceivePacket(std::move(packet));
+ sock_z_->ReceivePacket(std::move(packet));
// Third DATA, second fragment (lost)
packet = cb_a_.ConsumeSentPacket();
@@ -1167,20 +1169,20 @@
packet = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet, HasDataChunkWithPPID(PPID(54)));
EXPECT_THAT(packet, HasDataChunkWithSsn(SSN(0)));
- sock_z_.ReceivePacket(std::move(packet));
+ sock_z_->ReceivePacket(std::move(packet));
// Fourth DATA, second fragment
packet = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet, HasDataChunkWithPPID(PPID(54)));
EXPECT_THAT(packet, HasDataChunkWithSsn(SSN(0)));
- sock_z_.ReceivePacket(std::move(packet));
+ sock_z_->ReceivePacket(std::move(packet));
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
// Let the RTX timer expire, and exchange FORWARD-TSN/SACKs
AdvanceTime(options_.rto_initial);
RunTimers();
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
absl::optional<DcSctpMessage> msg1 = cb_z_.ConsumeReceivedMessage();
ASSERT_TRUE(msg1.has_value());
@@ -1212,9 +1214,9 @@
ConnectSockets();
// Inject a FAKE chunk
- SctpPacket::Builder b(sock_a_.verification_tag(), DcSctpOptions());
+ SctpPacket::Builder b(sock_a_->verification_tag(), DcSctpOptions());
b.Add(FakeChunk());
- sock_a_.ReceivePacket(b.Build());
+ sock_a_->ReceivePacket(b.Build());
// ERROR is sent as a reply. Capture it.
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket reply_packet,
@@ -1232,7 +1234,7 @@
ConnectSockets();
// Inject a ERROR chunk
- SctpPacket::Builder b(sock_a_.verification_tag(), DcSctpOptions());
+ SctpPacket::Builder b(sock_a_->verification_tag(), DcSctpOptions());
b.Add(
ErrorChunk(Parameters::Builder()
.Add(UnrecognizedChunkTypeCause({0x49, 0x00, 0x00, 0x04}))
@@ -1240,7 +1242,7 @@
EXPECT_CALL(cb_a_, OnError(ErrorKind::kPeerReported,
HasSubstr("Unrecognized Chunk Type")));
- sock_a_.ReceivePacket(b.Build());
+ sock_a_->ReceivePacket(b.Build());
}
TEST_F(DcSctpSocketTest, PassingHighWatermarkWillOnlyAcceptCumAckTsn) {
@@ -1255,7 +1257,7 @@
EXPECT_CALL(cb_z2, OnClosed).Times(0);
EXPECT_CALL(cb_z2, OnAborted).Times(0);
- sock_a_.Connect();
+ sock_a_->Connect();
std::vector<uint8_t> init_data = cb_a_.ConsumeSentPacket();
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket init_packet,
SctpPacket::Parse(init_data));
@@ -1263,9 +1265,9 @@
InitChunk init_chunk,
InitChunk::Parse(init_packet.descriptors()[0].data));
sock_z2.ReceivePacket(init_data);
- sock_a_.ReceivePacket(cb_z2.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z2.ConsumeSentPacket());
sock_z2.ReceivePacket(cb_a_.ConsumeSentPacket());
- sock_a_.ReceivePacket(cb_z2.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z2.ConsumeSentPacket());
// Fill up Z2 to the high watermark limit.
constexpr size_t kWatermarkLimit =
@@ -1353,8 +1355,8 @@
}
TEST_F(DcSctpSocketTest, SetMaxMessageSize) {
- sock_a_.SetMaxMessageSize(42u);
- EXPECT_EQ(sock_a_.options().max_message_size, 42u);
+ sock_a_->SetMaxMessageSize(42u);
+ EXPECT_EQ(sock_a_->options().max_message_size, 42u);
}
TEST_F(DcSctpSocketTest, SendsMessagesWithLowLifetime) {
@@ -1379,10 +1381,10 @@
send_options.unordered = IsUnordered((i % 2) == 0);
send_options.lifetime = DurationMs(i % 3); // 0, 1, 2 ms
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), send_options);
}
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
for (int i = 0; i < kIterations; ++i) {
EXPECT_TRUE(cb_z_.ConsumeReceivedMessage().has_value());
@@ -1418,12 +1420,12 @@
// Fill up the send buffer with a large message.
std::vector<uint8_t> payload(kLargeMessageSize);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), payload), kSendOptions);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), payload), kSendOptions);
// And queue a few small messages with lifetime=0 or 1 ms - can't be sent.
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2, 3}), lifetime_0);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), {4, 5, 6}), lifetime_1);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), {7, 8, 9}), lifetime_0);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2, 3}), lifetime_0);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), {4, 5, 6}), lifetime_1);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), {7, 8, 9}), lifetime_0);
// Handle all that was sent until congestion window got full.
for (;;) {
@@ -1431,14 +1433,14 @@
if (packet_from_a.empty()) {
break;
}
- sock_z_.ReceivePacket(std::move(packet_from_a));
+ sock_z_->ReceivePacket(std::move(packet_from_a));
}
// Shouldn't be enough to send that large message.
EXPECT_FALSE(cb_z_.ConsumeReceivedMessage().has_value());
// Exchange the rest of the messages, with the time ever increasing.
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
// The large message should be delivered. It was sent reliably.
ASSERT_HAS_VALUE_AND_ASSIGN(DcSctpMessage m1, cb_z_.ConsumeReceivedMessage());
@@ -1452,27 +1454,27 @@
TEST_F(DcSctpSocketTest, HasReasonableBufferedAmountValues) {
ConnectSockets();
- EXPECT_EQ(sock_a_.buffered_amount(StreamID(1)), 0u);
+ EXPECT_EQ(sock_a_->buffered_amount(StreamID(1)), 0u);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53),
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53),
std::vector<uint8_t>(kSmallMessageSize)),
kSendOptions);
// Sending a small message will directly send it as a single packet, so
// nothing is left in the queue.
- EXPECT_EQ(sock_a_.buffered_amount(StreamID(1)), 0u);
+ EXPECT_EQ(sock_a_->buffered_amount(StreamID(1)), 0u);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53),
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53),
std::vector<uint8_t>(kLargeMessageSize)),
kSendOptions);
// Sending a message will directly start sending a few packets, so the
// buffered amount is not the full message size.
- EXPECT_GT(sock_a_.buffered_amount(StreamID(1)), 0u);
- EXPECT_LT(sock_a_.buffered_amount(StreamID(1)), kLargeMessageSize);
+ EXPECT_GT(sock_a_->buffered_amount(StreamID(1)), 0u);
+ EXPECT_LT(sock_a_->buffered_amount(StreamID(1)), kLargeMessageSize);
}
TEST_F(DcSctpSocketTest, HasDefaultOnBufferedAmountLowValueZero) {
- EXPECT_EQ(sock_a_.buffered_amount_low_threshold(StreamID(1)), 0u);
+ EXPECT_EQ(sock_a_->buffered_amount_low_threshold(StreamID(1)), 0u);
}
TEST_F(DcSctpSocketTest, TriggersOnBufferedAmountLowWithDefaultValueZero) {
@@ -1480,75 +1482,75 @@
ConnectSockets();
EXPECT_CALL(cb_a_, OnBufferedAmountLow(StreamID(1)));
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53),
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53),
std::vector<uint8_t>(kSmallMessageSize)),
kSendOptions);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
}
TEST_F(DcSctpSocketTest, DoesntTriggerOnBufferedAmountLowIfBelowThreshold) {
static constexpr size_t kMessageSize = 1000;
static constexpr size_t kBufferedAmountLowThreshold = kMessageSize * 10;
- sock_a_.SetBufferedAmountLowThreshold(StreamID(1),
+ sock_a_->SetBufferedAmountLowThreshold(StreamID(1),
kBufferedAmountLowThreshold);
EXPECT_CALL(cb_a_, OnBufferedAmountLow).Times(0);
ConnectSockets();
EXPECT_CALL(cb_a_, OnBufferedAmountLow(StreamID(1))).Times(0);
- sock_a_.Send(
+ sock_a_->Send(
DcSctpMessage(StreamID(1), PPID(53), std::vector<uint8_t>(kMessageSize)),
kSendOptions);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
- sock_a_.Send(
+ sock_a_->Send(
DcSctpMessage(StreamID(1), PPID(53), std::vector<uint8_t>(kMessageSize)),
kSendOptions);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
}
TEST_F(DcSctpSocketTest, TriggersOnBufferedAmountMultipleTimes) {
static constexpr size_t kMessageSize = 1000;
static constexpr size_t kBufferedAmountLowThreshold = kMessageSize / 2;
- sock_a_.SetBufferedAmountLowThreshold(StreamID(1),
+ sock_a_->SetBufferedAmountLowThreshold(StreamID(1),
kBufferedAmountLowThreshold);
EXPECT_CALL(cb_a_, OnBufferedAmountLow).Times(0);
ConnectSockets();
EXPECT_CALL(cb_a_, OnBufferedAmountLow(StreamID(1))).Times(3);
EXPECT_CALL(cb_a_, OnBufferedAmountLow(StreamID(2))).Times(2);
- sock_a_.Send(
+ sock_a_->Send(
DcSctpMessage(StreamID(1), PPID(53), std::vector<uint8_t>(kMessageSize)),
kSendOptions);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
- sock_a_.Send(
+ sock_a_->Send(
DcSctpMessage(StreamID(2), PPID(53), std::vector<uint8_t>(kMessageSize)),
kSendOptions);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
- sock_a_.Send(
+ sock_a_->Send(
DcSctpMessage(StreamID(1), PPID(53), std::vector<uint8_t>(kMessageSize)),
kSendOptions);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
- sock_a_.Send(
+ sock_a_->Send(
DcSctpMessage(StreamID(2), PPID(53), std::vector<uint8_t>(kMessageSize)),
kSendOptions);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
- sock_a_.Send(
+ sock_a_->Send(
DcSctpMessage(StreamID(1), PPID(53), std::vector<uint8_t>(kMessageSize)),
kSendOptions);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
}
TEST_F(DcSctpSocketTest, TriggersOnBufferedAmountLowOnlyWhenCrossingThreshold) {
static constexpr size_t kMessageSize = 1000;
static constexpr size_t kBufferedAmountLowThreshold = kMessageSize * 1.5;
- sock_a_.SetBufferedAmountLowThreshold(StreamID(1),
+ sock_a_->SetBufferedAmountLowThreshold(StreamID(1),
kBufferedAmountLowThreshold);
EXPECT_CALL(cb_a_, OnBufferedAmountLow).Times(0);
ConnectSockets();
@@ -1557,18 +1559,18 @@
// Add a few messages to fill up the congestion window. When that is full,
// messages will start to be fully buffered.
- while (sock_a_.buffered_amount(StreamID(1)) <= kBufferedAmountLowThreshold) {
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53),
+ while (sock_a_->buffered_amount(StreamID(1)) <= kBufferedAmountLowThreshold) {
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53),
std::vector<uint8_t>(kMessageSize)),
kSendOptions);
}
- size_t initial_buffered = sock_a_.buffered_amount(StreamID(1));
+ size_t initial_buffered = sock_a_->buffered_amount(StreamID(1));
ASSERT_GT(initial_buffered, kBufferedAmountLowThreshold);
// Start ACKing packets, which will empty the send queue, and trigger the
// callback.
EXPECT_CALL(cb_a_, OnBufferedAmountLow(StreamID(1))).Times(1);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
}
TEST_F(DcSctpSocketTest, DoesntTriggerOnTotalBufferAmountLowWhenBelow) {
@@ -1576,11 +1578,11 @@
EXPECT_CALL(cb_a_, OnTotalBufferedAmountLow).Times(0);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53),
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53),
std::vector<uint8_t>(kLargeMessageSize)),
kSendOptions);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
}
TEST_F(DcSctpSocketTest, TriggersOnTotalBufferAmountLowWhenCrossingThreshold) {
@@ -1590,7 +1592,7 @@
// Fill up the send queue completely.
for (;;) {
- if (sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53),
+ if (sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53),
std::vector<uint8_t>(kLargeMessageSize)),
kSendOptions) == SendStatus::kErrorResourceExhaustion) {
break;
@@ -1598,11 +1600,11 @@
}
EXPECT_CALL(cb_a_, OnTotalBufferedAmountLow).Times(1);
- ExchangeMessages(sock_a_, cb_a_, sock_z_, cb_z_);
+ ExchangeMessages(*sock_a_, cb_a_, *sock_z_, cb_z_);
}
TEST_F(DcSctpSocketTest, InitialMetricsAreZeroed) {
- Metrics metrics = sock_a_.GetMetrics();
+ Metrics metrics = sock_a_->GetMetrics();
EXPECT_EQ(metrics.tx_packets_count, 0u);
EXPECT_EQ(metrics.tx_messages_count, 0u);
EXPECT_EQ(metrics.cwnd_bytes.has_value(), false);
@@ -1619,72 +1621,72 @@
const size_t initial_a_rwnd = options_.max_receiver_window_buffer_size *
ReassemblyQueue::kHighWatermarkLimit;
- EXPECT_EQ(sock_a_.GetMetrics().tx_packets_count, 2u);
- EXPECT_EQ(sock_a_.GetMetrics().rx_packets_count, 2u);
- EXPECT_EQ(sock_a_.GetMetrics().tx_messages_count, 0u);
- EXPECT_EQ(*sock_a_.GetMetrics().cwnd_bytes,
+ EXPECT_EQ(sock_a_->GetMetrics().tx_packets_count, 2u);
+ EXPECT_EQ(sock_a_->GetMetrics().rx_packets_count, 2u);
+ EXPECT_EQ(sock_a_->GetMetrics().tx_messages_count, 0u);
+ EXPECT_EQ(*sock_a_->GetMetrics().cwnd_bytes,
options_.cwnd_mtus_initial * options_.mtu);
- EXPECT_EQ(sock_a_.GetMetrics().unack_data_count, 0u);
+ EXPECT_EQ(sock_a_->GetMetrics().unack_data_count, 0u);
- EXPECT_EQ(sock_z_.GetMetrics().rx_packets_count, 2u);
- EXPECT_EQ(sock_z_.GetMetrics().rx_messages_count, 0u);
+ EXPECT_EQ(sock_z_->GetMetrics().rx_packets_count, 2u);
+ EXPECT_EQ(sock_z_->GetMetrics().rx_messages_count, 0u);
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), kSendOptions);
- EXPECT_EQ(sock_a_.GetMetrics().unack_data_count, 1u);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53), {1, 2}), kSendOptions);
+ EXPECT_EQ(sock_a_->GetMetrics().unack_data_count, 1u);
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket()); // DATA
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket()); // SACK
- EXPECT_EQ(*sock_a_.GetMetrics().peer_rwnd_bytes, initial_a_rwnd);
- EXPECT_EQ(sock_a_.GetMetrics().unack_data_count, 0u);
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket()); // DATA
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket()); // SACK
+ EXPECT_EQ(*sock_a_->GetMetrics().peer_rwnd_bytes, initial_a_rwnd);
+ EXPECT_EQ(sock_a_->GetMetrics().unack_data_count, 0u);
EXPECT_TRUE(cb_z_.ConsumeReceivedMessage().has_value());
- EXPECT_EQ(sock_a_.GetMetrics().tx_packets_count, 3u);
- EXPECT_EQ(sock_a_.GetMetrics().rx_packets_count, 3u);
- EXPECT_EQ(sock_a_.GetMetrics().tx_messages_count, 1u);
+ EXPECT_EQ(sock_a_->GetMetrics().tx_packets_count, 3u);
+ EXPECT_EQ(sock_a_->GetMetrics().rx_packets_count, 3u);
+ EXPECT_EQ(sock_a_->GetMetrics().tx_messages_count, 1u);
- EXPECT_EQ(sock_z_.GetMetrics().rx_packets_count, 3u);
- EXPECT_EQ(sock_z_.GetMetrics().rx_messages_count, 1u);
+ EXPECT_EQ(sock_z_->GetMetrics().rx_packets_count, 3u);
+ EXPECT_EQ(sock_z_->GetMetrics().rx_messages_count, 1u);
// Send one more (large - fragmented), and receive the delayed SACK.
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53),
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53),
std::vector<uint8_t>(options_.mtu * 2 + 1)),
kSendOptions);
- EXPECT_EQ(sock_a_.GetMetrics().unack_data_count, 3u);
+ EXPECT_EQ(sock_a_->GetMetrics().unack_data_count, 3u);
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket()); // DATA
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket()); // DATA
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket()); // DATA
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket()); // DATA
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket()); // SACK
- EXPECT_EQ(sock_a_.GetMetrics().unack_data_count, 1u);
- EXPECT_GT(*sock_a_.GetMetrics().peer_rwnd_bytes, 0u);
- EXPECT_LT(*sock_a_.GetMetrics().peer_rwnd_bytes, initial_a_rwnd);
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket()); // SACK
+ EXPECT_EQ(sock_a_->GetMetrics().unack_data_count, 1u);
+ EXPECT_GT(*sock_a_->GetMetrics().peer_rwnd_bytes, 0u);
+ EXPECT_LT(*sock_a_->GetMetrics().peer_rwnd_bytes, initial_a_rwnd);
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket()); // DATA
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket()); // DATA
EXPECT_TRUE(cb_z_.ConsumeReceivedMessage().has_value());
- EXPECT_EQ(sock_a_.GetMetrics().tx_packets_count, 6u);
- EXPECT_EQ(sock_a_.GetMetrics().rx_packets_count, 4u);
- EXPECT_EQ(sock_a_.GetMetrics().tx_messages_count, 2u);
+ EXPECT_EQ(sock_a_->GetMetrics().tx_packets_count, 6u);
+ EXPECT_EQ(sock_a_->GetMetrics().rx_packets_count, 4u);
+ EXPECT_EQ(sock_a_->GetMetrics().tx_messages_count, 2u);
- EXPECT_EQ(sock_z_.GetMetrics().rx_packets_count, 6u);
- EXPECT_EQ(sock_z_.GetMetrics().rx_messages_count, 2u);
+ EXPECT_EQ(sock_z_->GetMetrics().rx_packets_count, 6u);
+ EXPECT_EQ(sock_z_->GetMetrics().rx_messages_count, 2u);
// Delayed sack
AdvanceTime(options_.delayed_ack_max_timeout);
RunTimers();
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket()); // SACK
- EXPECT_EQ(sock_a_.GetMetrics().unack_data_count, 0u);
- EXPECT_EQ(sock_a_.GetMetrics().rx_packets_count, 5u);
- EXPECT_EQ(*sock_a_.GetMetrics().peer_rwnd_bytes, initial_a_rwnd);
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket()); // SACK
+ EXPECT_EQ(sock_a_->GetMetrics().unack_data_count, 0u);
+ EXPECT_EQ(sock_a_->GetMetrics().rx_packets_count, 5u);
+ EXPECT_EQ(*sock_a_->GetMetrics().peer_rwnd_bytes, initial_a_rwnd);
}
TEST_F(DcSctpSocketTest, UnackDataAlsoIncludesSendQueue) {
ConnectSockets();
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53),
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53),
std::vector<uint8_t>(kLargeMessageSize)),
kSendOptions);
size_t payload_bytes =
@@ -1699,24 +1701,24 @@
// Due to alignment, padding etc, it's hard to calculate the exact number, but
// it should be in this range.
- EXPECT_GE(sock_a_.GetMetrics().unack_data_count,
+ EXPECT_GE(sock_a_->GetMetrics().unack_data_count,
expected_sent_packets + expected_queued_packets);
- EXPECT_LE(sock_a_.GetMetrics().unack_data_count,
+ EXPECT_LE(sock_a_->GetMetrics().unack_data_count,
expected_sent_packets + expected_queued_packets + 2);
}
TEST_F(DcSctpSocketTest, DoesntSendMoreThanMaxBurstPackets) {
ConnectSockets();
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(53),
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(53),
std::vector<uint8_t>(kLargeMessageSize)),
kSendOptions);
for (int i = 0; i < kMaxBurstPackets; ++i) {
std::vector<uint8_t> packet = cb_a_.ConsumeSentPacket();
EXPECT_THAT(packet, Not(IsEmpty()));
- sock_z_.ReceivePacket(std::move(packet)); // DATA
+ sock_z_->ReceivePacket(std::move(packet)); // DATA
}
EXPECT_THAT(cb_a_.ConsumeSentPacket(), IsEmpty());
@@ -1727,7 +1729,7 @@
// A really large message, to ensure that the congestion window is often full.
constexpr size_t kMessageSize = 100000;
- sock_a_.Send(
+ sock_a_->Send(
DcSctpMessage(StreamID(1), PPID(53), std::vector<uint8_t>(kMessageSize)),
kSendOptions);
@@ -1739,12 +1741,12 @@
if (!packet_from_a.empty()) {
data_packet_sizes.push_back(packet_from_a.size());
delivered_packet = true;
- sock_z_.ReceivePacket(std::move(packet_from_a));
+ sock_z_->ReceivePacket(std::move(packet_from_a));
}
std::vector<uint8_t> packet_from_z = cb_z_.ConsumeSentPacket();
if (!packet_from_z.empty()) {
delivered_packet = true;
- sock_a_.ReceivePacket(std::move(packet_from_z));
+ sock_a_->ReceivePacket(std::move(packet_from_z));
}
} while (delivered_packet);
@@ -1778,31 +1780,31 @@
constexpr DurationMs kRtt = DurationMs(80);
AdvanceTime(kRtt);
- sock_z_.ReceivePacket(hb_req_a);
- sock_a_.ReceivePacket(hb_req_z);
+ sock_z_->ReceivePacket(hb_req_a);
+ sock_a_->ReceivePacket(hb_req_z);
// HEARTBEAT_ACK
- sock_a_.ReceivePacket(cb_z_.ConsumeSentPacket());
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_a_->ReceivePacket(cb_z_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
SendOptions send_options;
send_options.max_retransmissions = 0;
std::vector<uint8_t> payload(options_.mtu - 100);
// Send an initial message that is received, but the SACK was lost
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(51), payload), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(51), payload), send_options);
// DATA
- sock_z_.ReceivePacket(cb_a_.ConsumeSentPacket());
+ sock_z_->ReceivePacket(cb_a_.ConsumeSentPacket());
// SACK (lost)
std::vector<uint8_t> sack = cb_z_.ConsumeSentPacket();
// Queue enough messages to fill the congestion window.
do {
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(51), payload), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(51), payload), send_options);
} while (!cb_a_.ConsumeSentPacket().empty());
// Enqueue at least one more.
- sock_a_.Send(DcSctpMessage(StreamID(1), PPID(51), payload), send_options);
+ sock_a_->Send(DcSctpMessage(StreamID(1), PPID(51), payload), send_options);
// Let all of them expire by T3-RTX and inspect what's sent.
AdvanceTime(options_.rto_initial);
@@ -1825,7 +1827,7 @@
}
// Replay the SACK, and see if a FORWARD-TSN is sent again.
- sock_a_.ReceivePacket(sack);
+ sock_a_->ReceivePacket(sack);
// It shouldn't be sent as not enough time has passed yet. Instead, more
// DATA chunks are sent, that are in the queue.
@@ -1837,7 +1839,7 @@
// Now let RTT time pass, to allow a FORWARD-TSN to be sent again.
AdvanceTime(kRtt);
- sock_a_.ReceivePacket(sack);
+ sock_a_->ReceivePacket(sack);
std::vector<uint8_t> sent4 = cb_a_.ConsumeSentPacket();
ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket packet4, SctpPacket::Parse(sent4));
