From cfee05464cf84591a7323e6255bf6c7449afb71c Mon Sep 17 00:00:00 2001 From: Sergey Sukhanov Date: Mon, 6 Sep 2021 12:58:16 +0200 Subject: [PATCH] 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 Commit-Queue: Sergey Sukhanov Cr-Commit-Position: refs/heads/main@{#34931} --- net/dcsctp/common/internal_types.h | 1 + net/dcsctp/socket/dcsctp_socket_test.cc | 568 ++++++++++++------------ 2 files changed, 286 insertions(+), 283 deletions(-) diff --git a/net/dcsctp/common/internal_types.h b/net/dcsctp/common/internal_types.h index 3bbc05e445..e7dabf303d 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 #include #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 c0d7725ba5..5f99cc91be 100644 --- a/net/dcsctp/socket/dcsctp_socket_test.cc +++ b/net/dcsctp/socket/dcsctp_socket_test.cc @@ -254,8 +254,10 @@ class DcSctpSocketTest : public testing::Test { : 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( + "A", cb_a_, GetPacketObserver("A"), options_)), + sock_z_(std::make_unique( + "Z", cb_z_, GetPacketObserver("Z"), options_)) {} void AdvanceTime(DurationMs duration) { cb_a_.AdvanceTime(duration); @@ -293,8 +295,8 @@ class DcSctpSocketTest : public testing::Test { } 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 @@ class DcSctpSocketTest : public testing::Test { 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 cb_a_; testing::NiceMock cb_z_; - DcSctpSocket sock_a_; - DcSctpSocket sock_z_; + std::unique_ptr sock_a_; + std::unique_ptr sock_z_; }; TEST_F(DcSctpSocketTest, EstablishConnection) { @@ -326,18 +328,18 @@ TEST_F(DcSctpSocketTest, EstablishConnection) { 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 @@ TEST_F(DcSctpSocketTest, EstablishConnectionWithSetupCollision) { 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 @@ TEST_F(DcSctpSocketTest, EstablishSimultaneousConnection) { 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 @@ TEST_F(DcSctpSocketTest, EstablishConnectionLostCookieAck) { 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 @@ TEST_F(DcSctpSocketTest, ResendInitAndEstablishConnection) { 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 @@ TEST_F(DcSctpSocketTest, ResendingInitTooManyTimesAborts) { 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 @@ TEST_F(DcSctpSocketTest, ResendCookieEchoAndEstablishConnection) { 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 @@ TEST_F(DcSctpSocketTest, ResendingCookieEchoTooManyTimesAborts) { 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(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 @@ TEST_F(DcSctpSocketTest, DoesntSendMorePacketsUntilCookieAckHasBeenReceived) { 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 @@ TEST_F(DcSctpSocketTest, ShutdownConnection) { 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 @@ TEST_F(DcSctpSocketTest, ShutdownTimerExpiresTooManyTimeClosesConnection) { 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, ShutdownTimerExpiresTooManyTimeClosesConnection) { } 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 msg = cb_z_.ConsumeReceivedMessage(); ASSERT_TRUE(msg.has_value()); @@ -694,8 +696,8 @@ TEST_F(DcSctpSocketTest, EstablishConnectionWhileSendingData) { 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 msg = cb_z_.ConsumeReceivedMessage(); ASSERT_TRUE(msg.has_value()); @@ -705,14 +707,14 @@ TEST_F(DcSctpSocketTest, SendMessageAfterEstablished) { 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 msg = cb_z_.ConsumeReceivedMessage(); ASSERT_TRUE(msg.has_value()); @@ -723,15 +725,15 @@ TEST_F(DcSctpSocketTest, SendALotOfBytesMissedSecondPacket) { ConnectSockets(); std::vector 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 msg = cb_z_.ConsumeReceivedMessage(); ASSERT_TRUE(msg.has_value()); @@ -743,12 +745,12 @@ TEST_F(DcSctpSocketTest, SendingHeartbeatAnswersWithAck) { 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 @@ TEST_F(DcSctpSocketTest, ExpectHeartbeatToBeSent) { 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 @@ TEST_F(DcSctpSocketTest, CloseConnectionAfterTooManyLostHeartbeats) { 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 @@ TEST_F(DcSctpSocketTest, RecoversAfterASuccessfulAck) { 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 @@ TEST_F(DcSctpSocketTest, RecoversAfterASuccessfulAck) { 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, RecoversAfterASuccessfulAck) { 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 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(1)})); + sock_a_->ResetStreams(std::vector({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 @@ TEST_F(DcSctpSocketTest, ResetStreamWillMakeChunksStartAtZeroSsn) { std::vector 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 msg1 = cb_z_.ConsumeReceivedMessage(); ASSERT_TRUE(msg1.has_value()); @@ -934,26 +936,26 @@ TEST_F(DcSctpSocketTest, ResetStreamWillMakeChunksStartAtZeroSsn) { EXPECT_EQ(msg2->stream_id(), StreamID(1)); // Reset the outgoing stream. This will directly send a RE-CONFIG. - sock_a_.ResetStreams(std::vector({StreamID(1)})); + sock_a_->ResetStreams(std::vector({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 @@ TEST_F(DcSctpSocketTest, ResetStreamWillOnlyResetTheRequestedStreams) { std::vector 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 msg1 = cb_z_.ConsumeReceivedMessage(); @@ -1009,29 +1011,29 @@ TEST_F(DcSctpSocketTest, ResetStreamWillOnlyResetTheRequestedStreams) { EXPECT_EQ(msg4->stream_id(), StreamID(3)); // Reset SID 1. This will directly send a RE-CONFIG. - sock_a_.ResetStreams(std::vector({StreamID(3)})); + sock_a_->ResetStreams(std::vector({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 @@ TEST_F(DcSctpSocketTest, OnePeerReconnects) { // 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 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 cb_z2("Z2"); @@ -1054,7 +1056,7 @@ TEST_F(DcSctpSocketTest, OnePeerReconnects) { // 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 msg = cb_z2.ConsumeReceivedMessage(); ASSERT_TRUE(msg.has_value()); @@ -1068,26 +1070,26 @@ TEST_F(DcSctpSocketTest, SendMessageWithLimitedRtx) { SendOptions send_options; send_options.max_retransmissions = 0; std::vector 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 @@ TEST_F(DcSctpSocketTest, SendMessageWithLimitedRtx) { // 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 msg1 = cb_z_.ConsumeReceivedMessage(); ASSERT_TRUE(msg1.has_value()); @@ -1125,18 +1127,18 @@ TEST_F(DcSctpSocketTest, SendManyFragmentedMessagesWithLimitedRtx) { send_options.max_retransmissions = 0; std::vector 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 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 @@ TEST_F(DcSctpSocketTest, SendManyFragmentedMessagesWithLimitedRtx) { // 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 @@ TEST_F(DcSctpSocketTest, SendManyFragmentedMessagesWithLimitedRtx) { 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 @@ TEST_F(DcSctpSocketTest, SendManyFragmentedMessagesWithLimitedRtx) { 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 msg1 = cb_z_.ConsumeReceivedMessage(); ASSERT_TRUE(msg1.has_value()); @@ -1212,9 +1214,9 @@ TEST_F(DcSctpSocketTest, ReceivingUnknownChunkRespondsWithError) { 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 @@ TEST_F(DcSctpSocketTest, ReceivingErrorChunkReportsAsCallback) { 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 @@ TEST_F(DcSctpSocketTest, ReceivingErrorChunkReportsAsCallback) { 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 @@ TEST_F(DcSctpSocketTest, PassingHighWatermarkWillOnlyAcceptCumAckTsn) { EXPECT_CALL(cb_z2, OnClosed).Times(0); EXPECT_CALL(cb_z2, OnAborted).Times(0); - sock_a_.Connect(); + sock_a_->Connect(); std::vector init_data = cb_a_.ConsumeSentPacket(); ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket init_packet, SctpPacket::Parse(init_data)); @@ -1263,9 +1265,9 @@ TEST_F(DcSctpSocketTest, PassingHighWatermarkWillOnlyAcceptCumAckTsn) { 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, PassingHighWatermarkWillOnlyAcceptCumAckTsn) { } 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 @@ TEST_F(DcSctpSocketTest, SendsMessagesWithLowLifetime) { 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 @@ TEST_F(DcSctpSocketTest, DiscardsMessagesWithLowLifetimeIfMustBuffer) { // Fill up the send buffer with a large message. std::vector 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 @@ TEST_F(DcSctpSocketTest, DiscardsMessagesWithLowLifetimeIfMustBuffer) { 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, DiscardsMessagesWithLowLifetimeIfMustBuffer) { 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(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(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 @@ TEST_F(DcSctpSocketTest, TriggersOnBufferedAmountLowWithDefaultValueZero) { 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(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(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(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(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(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(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(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(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 @@ TEST_F(DcSctpSocketTest, TriggersOnBufferedAmountLowOnlyWhenCrossingThreshold) { // 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(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 @@ TEST_F(DcSctpSocketTest, DoesntTriggerOnTotalBufferAmountLowWhenBelow) { 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(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 @@ TEST_F(DcSctpSocketTest, TriggersOnTotalBufferAmountLowWhenCrossingThreshold) { // 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(kLargeMessageSize)), kSendOptions) == SendStatus::kErrorResourceExhaustion) { break; @@ -1598,11 +1600,11 @@ TEST_F(DcSctpSocketTest, TriggersOnTotalBufferAmountLowWhenCrossingThreshold) { } 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 @@ TEST_F(DcSctpSocketTest, RxAndTxPacketMetricsIncrease) { 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(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(kLargeMessageSize)), kSendOptions); size_t payload_bytes = @@ -1699,24 +1701,24 @@ TEST_F(DcSctpSocketTest, UnackDataAlsoIncludesSendQueue) { // 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(kLargeMessageSize)), kSendOptions); for (int i = 0; i < kMaxBurstPackets; ++i) { std::vector 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 @@ TEST_F(DcSctpSocketTest, SendsOnlyLargePackets) { // 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(kMessageSize)), kSendOptions); @@ -1739,12 +1741,12 @@ TEST_F(DcSctpSocketTest, SendsOnlyLargePackets) { 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 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 @@ TEST_F(DcSctpSocketTest, DoesntBundleForwardTsnWithData) { 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 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 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 @@ TEST_F(DcSctpSocketTest, DoesntBundleForwardTsnWithData) { } // 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 @@ TEST_F(DcSctpSocketTest, DoesntBundleForwardTsnWithData) { // 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 sent4 = cb_a_.ConsumeSentPacket(); ASSERT_HAS_VALUE_AND_ASSIGN(SctpPacket packet4, SctpPacket::Parse(sent4));