transmission_control_block_test.cc

/*

 *  Copyright (c) 2023 The WebRTC project authors. All Rights Reserved.

 *  Use of this source code is governed by a BSD-style license

 *  that can be found in the LICENSE file in the root of the source

 *  tree. An additional intellectual property rights grant can be found

 *  in the file PATENTS.  All contributing project authors may

 *  be found in the AUTHORS file in the root of the source tree.

*/

#include "net/dcsctp/socket/transmission_control_block.h"

#include <array>

#include <cstdint>

#include <memory>

#include <type_traits>

#include <vector>

#include "absl/types/optional.h"

#include "api/array_view.h"

#include "api/task_queue/task_queue_base.h"

#include "net/dcsctp/common/handover_testing.h"

#include "net/dcsctp/common/internal_types.h"

#include "net/dcsctp/packet/chunk/reconfig_chunk.h"

#include "net/dcsctp/packet/parameter/incoming_ssn_reset_request_parameter.h"

#include "net/dcsctp/packet/parameter/outgoing_ssn_reset_request_parameter.h"

#include "net/dcsctp/packet/parameter/parameter.h"

#include "net/dcsctp/packet/parameter/reconfiguration_response_parameter.h"

#include "net/dcsctp/public/dcsctp_message.h"

#include "net/dcsctp/rx/data_tracker.h"

#include "net/dcsctp/rx/reassembly_queue.h"

#include "net/dcsctp/socket/capabilities.h"

#include "net/dcsctp/socket/mock_context.h"

#include "net/dcsctp/socket/mock_dcsctp_socket_callbacks.h"

#include "net/dcsctp/testing/data_generator.h"

#include "net/dcsctp/testing/testing_macros.h"

#include "net/dcsctp/timer/timer.h"

#include "net/dcsctp/tx/mock_send_queue.h"

#include "net/dcsctp/tx/retransmission_queue.h"

#include "rtc_base/gunit.h"

#include "test/gmock.h"

namespace dcsctp {

namespace {

using ::testing::Return;

using ::testing::StrictMock;

constexpr VerificationTag kMyVerificationTag = VerificationTag(123);

constexpr VerificationTag kPeerVerificationTag = VerificationTag(456);

constexpr TSN kMyInitialTsn = TSN(10);

constexpr TSN kPeerInitialTsn = TSN(1000);

constexpr size_t kArwnd = 65536;

constexpr TieTag kTieTag = TieTag(12345678);

class TransmissionControlBlockTest : public testing::Test {

 protected:

  TransmissionControlBlockTest()

      : sender_(callbacks_, on_send_fn_.AsStdFunction()),

        timer_manager_([this](webrtc::TaskQueueBase::DelayPrecision precision) {

          return callbacks_.CreateTimeout(precision);

        }) {}

  DcSctpOptions options_;

  Capabilities capabilities_;

  StrictMock<MockDcSctpSocketCallbacks> callbacks_;

  StrictMock<MockSendQueue> send_queue_;

  testing::MockFunction<void(rtc::ArrayView<const uint8_t>, SendPacketStatus)>

      on_send_fn_;

  testing::MockFunction<bool()> on_connection_established;

  PacketSender sender_;

  TimerManager timer_manager_;

};

TEST_F(TransmissionControlBlockTest, LogsBasicInfoInToString) {

  EXPECT_CALL(send_queue_, EnableMessageInterleaving);

  capabilities_.negotiated_maximum_incoming_streams = 1000;

  capabilities_.negotiated_maximum_outgoing_streams = 2000;

  TransmissionControlBlock tcb(

      timer_manager_, "log: ", options_, capabilities_, callbacks_, send_queue_,

      kMyVerificationTag, kMyInitialTsn, kPeerVerificationTag, kPeerInitialTsn,

      kArwnd, kTieTag, sender_, on_connection_established.AsStdFunction());

  EXPECT_EQ(tcb.ToString(),

            "verification_tag=000001c8, last_cumulative_ack=999, capabilities= "

            "max_in=1000 max_out=2000");

TEST_F(TransmissionControlBlockTest, LogsAllCapabilitiesInToSring) {

  EXPECT_CALL(send_queue_, EnableMessageInterleaving);

  capabilities_.negotiated_maximum_incoming_streams = 1000;

  capabilities_.negotiated_maximum_outgoing_streams = 2000;

  capabilities_.message_interleaving = true;

  capabilities_.partial_reliability = true;

  capabilities_.zero_checksum = true;

  capabilities_.reconfig = true;

  TransmissionControlBlock tcb(

      timer_manager_, "log: ", options_, capabilities_, callbacks_, send_queue_,

      kMyVerificationTag, kMyInitialTsn, kPeerVerificationTag, kPeerInitialTsn,

      kArwnd, kTieTag, sender_, on_connection_established.AsStdFunction());

  EXPECT_EQ(

      tcb.ToString(),

      "verification_tag=000001c8, last_cumulative_ack=999, "

      "capabilities=PR,IL,Reconfig,ZeroChecksum, max_in=1000 max_out=2000");

TEST_F(TransmissionControlBlockTest, IsInitiallyHandoverReady) {

  EXPECT_CALL(send_queue_, EnableMessageInterleaving);

  EXPECT_CALL(send_queue_, HasStreamsReadyToBeReset).WillOnce(Return(false));

  TransmissionControlBlock tcb(

      timer_manager_, "log: ", options_, capabilities_, callbacks_, send_queue_,

      kMyVerificationTag, kMyInitialTsn, kPeerVerificationTag, kPeerInitialTsn,

      kArwnd, kTieTag, sender_, on_connection_established.AsStdFunction());

  EXPECT_TRUE(tcb.GetHandoverReadiness().IsReady());

}  // namespace

}  // namespace dcsctp