// SPDX-FileCopyrightText: 2026 The Pion community <https://pion.ly>

// SPDX-License-Identifier: MIT

//go:build !js

package sctp

import (

"context"

cryptoRand "crypto/rand"

"encoding/binary"

"encoding/json"

"errors"

"fmt"

"io"

"math"

"math/rand"

"net"

"os"

"runtime"

"strings"

"sync"

"sync/atomic"

"testing"

"time"

"github.com/pion/logging"

"github.com/pion/transport/v4/test"

"github.com/stretchr/testify/assert"

"github.com/stretchr/testify/require"

)

var (

errHandshakeFailed = errors.New("handshake failed")

errSINotMatch = errors.New("SI should match")

errReadData = errors.New("failed to read data")

errReceivedDataNot3Bytes = errors.New("received data must by 3 bytes")

errPPIUnexpected = errors.New("unexpected ppi")

errReceivedDataMismatch = errors.New("received data mismatch")

)

func TestAssocStressDuplex(t *testing.T) {

// Limit runtime in case of deadlocks

lim := test.TimeOut(time.Second * 20)

defer lim.Stop()

// Check for leaking routines

report := test.CheckRoutines(t)

defer report()

stressDuplex(t)

}

func stressDuplex(t *testing.T) {

t.Helper()

ca, cb, stop, err := pipe(t, pipeDump)

assert.NoError(t, err)

defer stop(t)

// Need to Increase once SCTP is more reliable in case of slow reader

opt := test.Options{

MsgSize: 2048, // 65535,

MsgCount: 10, // 1000,

}

err = test.StressDuplex(ca, cb, opt)

assert.NoError(t, err)

}

func pipe(t *testing.T, piper piperFunc) (*Stream, *Stream, func(*testing.T), error) {

t.Helper()

var err error

var aa, ab *Association

aa, ab, err = association(t, piper)

if err != nil {

return nil, nil, nil, err

}

var sa, sb *Stream

sa, err = aa.OpenStream(0, 0)

if err != nil {

return nil, nil, nil, err

}

sb, err = ab.OpenStream(0, 0)

if err != nil {

return nil, nil, nil, err

}

stop := func(t *testing.T) {

t.Helper()

err = sa.Close()

assert.NoError(t, err)

err = sb.Close()

assert.NoError(t, err)

err = aa.Close()

assert.NoError(t, err)

err = ab.Close()

assert.NoError(t, err)

}

return sa, sb, stop, nil

}

func association( //nolint:cyclop

t *testing.T,

piper piperFunc,

opts ...AssociationOption,

) (*Association, *Association, error) {

t.Helper()

ca, cb := piper(t)

loggerFactory := logging.NewDefaultLoggerFactory()

clientOpts := make([]ClientOption, 0, len(opts)+2)

serverOpts := make([]ServerOption, 0, len(opts)+2)

clientOpts = append(clientOpts, WithNetConn(ca), WithLoggerFactory(loggerFactory))

serverOpts = append(serverOpts, WithNetConn(cb), WithLoggerFactory(loggerFactory))

for _, opt := range opts {

clientOpts = append(clientOpts, opt)

serverOpts = append(serverOpts, opt)

}

type result struct {

side string

a *Association

err error

}

ch := make(chan result, 2)

go func() {

a, err := ClientWithOptions(clientOpts...)

ch <- result{side: "client", a: a, err: err}

}()

go func() {

a, err := ServerWithOptions(serverOpts...)

ch <- result{side: "server", a: a, err: err}

}()

timeout := 5 * time.Second

if dl, ok := t.Deadline(); ok {

if rem := time.Until(dl); rem > 0 && rem < timeout {

timeout = rem

}

}

timer := time.NewTimer(timeout)

defer timer.Stop()

var client, server *Association

for client == nil || server == nil {

select {

case res := <-ch:

if res.err != nil {

_ = ca.Close()

_ = cb.Close()

return nil, nil, res.err

}

if res.side == "client" {

client = res.a

} else {

server = res.a

}

case <-timer.C:

_ = ca.Close()

_ = cb.Close()

return nil, nil, fmt.Errorf("timeout establishing association") //nolint:err113

}

}

return client, server, nil

}

type piperFunc func(t *testing.T) (net.Conn, net.Conn)

func pipeDump(t *testing.T) (net.Conn, net.Conn) {

t.Helper()

aConn := acceptDumbConn(t)

addr, ok := aConn.LocalAddr().(*net.UDPAddr)

assert.True(t, ok)

bConn, err := net.DialUDP("udp4", nil, addr)

assert.NoError(t, err)

// Dumb handshake

mgs := "Test"

_, err = bConn.Write([]byte(mgs))

assert.NoError(t, err)

b := make([]byte, 4)

_, err = aConn.Read(b)

assert.NoError(t, err)

assert.Equal(t, string(b), mgs)

return aConn, bConn

}

type dumbConn struct {

mu sync.RWMutex

rAddr net.Addr

pConn net.PacketConn

}

func acceptDumbConn(t *testing.T) *dumbConn {

t.Helper()

pConn, err := net.ListenUDP("udp4", nil)

assert.NoError(t, err)

return &dumbConn{

pConn: pConn,

}

}

// Read.

func (c *dumbConn) Read(p []byte) (int, error) {

i, rAddr, err := c.pConn.ReadFrom(p)

if err != nil {

return 0, err

}

c.mu.Lock()

c.rAddr = rAddr

c.mu.Unlock()

return i, err

}

// Write writes len(p) bytes from p to the DTLS connection.

func (c *dumbConn) Write(p []byte) (n int, err error) {

return c.pConn.WriteTo(p, c.RemoteAddr())

}

// Close closes the conn and releases any Read calls.

func (c *dumbConn) Close() error {

return c.pConn.Close()

}

// LocalAddr is a stub.

func (c *dumbConn) LocalAddr() net.Addr {

if c.pConn != nil {

return c.pConn.LocalAddr()

}

return nil

}

// RemoteAddr is a stub.

func (c *dumbConn) RemoteAddr() net.Addr {

c.mu.RLock()

defer c.mu.RUnlock()

return c.rAddr

}

// SetDeadline is a stub.

func (c *dumbConn) SetDeadline(time.Time) error {

return nil

}

// SetReadDeadline is a stub.

func (c *dumbConn) SetReadDeadline(time.Time) error {

return nil

}

// SetWriteDeadline is a stub.

func (c *dumbConn) SetWriteDeadline(time.Time) error {

return nil

}

//nolint:cyclop

func createNewAssociationPair(

br *test.Bridge,

ackMode int,

recvBufSize uint32,

) (*Association, *Association, error) {

return createNewAssociationPairWithInterleaving(br, ackMode, recvBufSize, false, false)

}

//nolint:cyclop

func createNewAssociationPairWithInterleaving(

br *test.Bridge,

ackMode int,

recvBufSize uint32,

clientInterleaving bool,

serverInterleaving bool,

) (*Association, *Association, error) {

c0 := br.GetConn0()

c1 := br.GetConn1()

loggerFactory := logging.NewDefaultLoggerFactory()

type result struct {

side int // 0 => a0 (client), 1 => a1 (server)

a *Association

err error

}

ch := make(chan result, 2)

go func() {

opts := []ClientOption{

WithName("a0"),

WithNetConn(c0),

WithLoggerFactory(loggerFactory),

WithEnableInterleaving(clientInterleaving),

}

if recvBufSize != 0 {

opts = append(opts, WithMaxReceiveBufferSize(recvBufSize))

}

a, err := ClientWithOptions(opts...)

ch <- result{side: 0, a: a, err: err}

}()

go func() {

opts := []ServerOption{

WithName("a1"),

WithNetConn(c1),

WithLoggerFactory(loggerFactory),

WithEnableInterleaving(serverInterleaving),

}

if recvBufSize != 0 {

opts = append(opts, WithMaxReceiveBufferSize(recvBufSize))

}

a, err := ServerWithOptions(opts...)

ch <- result{side: 1, a: a, err: err}

}()

var (

a0, a1 *Association

err0 error

err1 error

)

for i := 0; i < 100 && (a0 == nil || a1 == nil); i++ {

time.Sleep(10 * time.Millisecond)

br.Tick()

for {

select {

case r := <-ch:

if r.side == 0 {

a0, err0 = r.a, r.err

} else {

a1, err1 = r.a, r.err

}

if err0 != nil || err1 != nil {

_ = c0.Close()

_ = c1.Close()

if err0 != nil {

return nil, nil, err0

}

return nil, nil, err1

}

default:

goto nextTick

}

}

nextTick:

}

if a0 == nil || a1 == nil {

_ = c0.Close()

_ = c1.Close()

return nil, nil, errHandshakeFailed

}

a0.ackMode = ackMode

a1.ackMode = ackMode

return a0, a1, nil

}

func closeAssociationPair(br *test.Bridge, a0, a1 *Association) {

close0Ch := make(chan bool)

close1Ch := make(chan bool)

go func() {

// nolint:errcheck,gosec

a0.Close()

close0Ch <- true

}()

go func() {

// nolint:errcheck,gosec

a1.Close()

close1Ch <- true

}()

a0closed := false

a1closed := false

loop1:

for range 100 {

time.Sleep(10 * time.Millisecond)

br.Tick()

select {

case a0closed = <-close0Ch:

if a1closed {

break loop1

}

case a1closed = <-close1Ch:

if a0closed {

break loop1

}

default:

}

}

}

func flushBuffers(br *test.Bridge, a0, a1 *Association) {

for {

for {

n := br.Tick()

if n == 0 {

break

}

}

if a0.BufferedAmount() == 0 && a1.BufferedAmount() == 0 {

break

}

time.Sleep(10 * time.Millisecond)

}

}

func establishSessionPair(br *test.Bridge, a0, a1 *Association, si uint16) (*Stream, *Stream, error) {

helloMsg := "Hello" // mimic datachannel.channelOpen

s0, err := a0.OpenStream(si, PayloadTypeWebRTCBinary)

if err != nil {

return nil, nil, err

}

_, err = s0.WriteSCTP([]byte(helloMsg), PayloadTypeWebRTCDCEP)

if err != nil {

return nil, nil, err

}

flushBuffers(br, a0, a1)

s1, err := a1.AcceptStream()

if err != nil {

return nil, nil, err

}

if s0.streamIdentifier != s1.streamIdentifier {

return nil, nil, errSINotMatch

}

br.Process()

buf := make([]byte, 1024)

n, ppi, err := s1.ReadSCTP(buf)

if err != nil {

return nil, nil, errReadData

}

if n != len(helloMsg) {

return nil, nil, errReceivedDataNot3Bytes

}

if ppi != PayloadTypeWebRTCDCEP {

return nil, nil, errPPIUnexpected

}

if string(buf[:n]) != helloMsg {

return nil, nil, errReceivedDataMismatch

}

flushBuffers(br, a0, a1)

return s0, s1, nil

}

func capturePayloadChunkTypes(br *test.Bridge, fromID int) <-chan chunkType {

chunkTypes := make(chan chunkType, 8)

br.Filter(fromID, func(raw []byte) bool {

p := &packet{}

if err := p.unmarshal(true, raw); err != nil {

return true

}

for _, c := range p.chunks {

if pd, ok := c.(*chunkPayloadData); ok {

chunkTypes <- pd.typ

}

}

return true

})

return chunkTypes

}

func captureChunkTypes(br *test.Bridge, fromID int) <-chan chunkType {

chunkTypes := make(chan chunkType, 16)

br.Filter(fromID, func(raw []byte) bool {

p := &packet{}

if err := p.unmarshal(true, raw); err != nil {

return true

}

for _, c := range p.chunks {

switch typed := c.(type) {

case *chunkPayloadData:

chunkTypes <- typed.typ

case *chunkForwardTSN:

chunkTypes <- ctForwardTSN

case *chunkIForwardTSN:

chunkTypes <- ctIForwardTSN

case *chunkSelectiveAck:

chunkTypes <- ctSack

}

}

return true

})

return chunkTypes

}

func requireNextPayloadChunkType(t *testing.T, chunkTypes <-chan chunkType, expected chunkType) {

t.Helper()

select {

case actual := <-chunkTypes:

require.Equal(t, expected, actual)

case <-time.After(500 * time.Millisecond):

require.Fail(t, "timed out waiting for payload chunk")

}

}

func requireCompletesWithin(t *testing.T, timeout time.Duration, f func()) {

t.Helper()

done := make(chan struct{})

go func() {

defer close(done)

f()

}()

select {

case <-done:

case <-time.After(timeout):

require.Failf(t, "operation timed out", "did not complete within %s", timeout)

}

}

func requireEventuallyChunkType(t *testing.T, chunkTypes <-chan chunkType, expected chunkType) {

t.Helper()

timeout := time.After(time.Second)

for {

select {

case actual := <-chunkTypes:

if actual == expected {

return

}

case <-timeout:

require.Failf(t, "timed out waiting for chunk type", "expected %s", expected)

}

}

}

func captureProtocolViolationAborts(br *test.Bridge, fromID int) <-chan string {

reasons := make(chan string, 4)

br.Filter(fromID, func(raw []byte) bool {

p := &packet{}

if err := p.unmarshal(true, raw); err != nil {

return true

}

for _, c := range p.chunks {

abort, ok := c.(*chunkAbort)

if !ok {

continue

}

for _, cause := range abort.errorCauses {

protocolViolation, ok := cause.(*errorCauseProtocolViolation)

if !ok {

continue

}

select {

case reasons <- string(protocolViolation.additionalInformation):

default:

}

}

}

return true

})

return reasons

}

func marshalPayloadPacketFromAssociation(t *testing.T, assoc *Association, iData bool) []byte {

t.Helper()

payload := &chunkPayloadData{

tsn: assoc.myNextTSN,

streamIdentifier: 1,

streamSequenceNumber: 0,

messageIdentifier: 0,

payloadType: PayloadTypeWebRTCBinary,

userData: []byte("bad"),

beginningFragment: true,

endingFragment: true,

iData: iData,

}

p := &packet{

sourcePort: assoc.sourcePort,

destinationPort: assoc.destinationPort,

verificationTag: assoc.peerVerificationTag,

chunks: []chunk{payload},

}

raw, err := assoc.marshalPacket(p)

require.NoError(t, err)

return raw

}

func marshalChunkPacketFromAssociation(t *testing.T, a *Association, c chunk) []byte {

t.Helper()

p := &packet{

sourcePort: a.sourcePort,

destinationPort: a.destinationPort,

verificationTag: a.peerVerificationTag,

chunks: []chunk{c},

}

raw, err := a.marshalPacket(p)

require.NoError(t, err)

return raw

}

func requireProtocolViolationAbort(

t *testing.T,

br *test.Bridge,

assoc *Association,

reasons <-chan string,

expectedReason string,

) {

t.Helper()

timer := time.NewTimer(time.Second)

defer timer.Stop()

ticker := time.NewTicker(10 * time.Millisecond)

defer ticker.Stop()

for {

select {

case reason := <-reasons:

require.Equal(t, expectedReason, reason)

return

case <-assoc.abortSentCh:

require.Fail(t, "abort was sent without captured protocol violation reason")

return

case <-ticker.C:

br.Tick()

case <-timer.C:

require.Fail(t, "timed out waiting for protocol violation abort")

return

}

}

}

func TestAssociationPRForwardTSNChunkTypeMatchesInterleaving(t *testing.T) {

tests := []struct {

name string

enableInterleaving bool

expectedForwardType chunkType

}{

{

name: "DATA uses FORWARD-TSN",

enableInterleaving: false,

expectedForwardType: ctForwardTSN,

},

{

name: "I-DATA uses I-FORWARD-TSN",

enableInterleaving: true,

expectedForwardType: ctIForwardTSN,

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

lim := test.TimeOut(time.Second * 10)

defer lim.Stop()

const si uint16 = 1

br := test.NewBridge()

a0, a1, err := createNewAssociationPairWithInterleaving(

br,

ackModeNoDelay,

0,

tt.enableInterleaving,

tt.enableInterleaving,

)

require.NoError(t, err, "failed to create associations")

defer closeAssociationPair(br, a0, a1)

s0, s1, err := establishSessionPair(br, a0, a1, si)

require.NoError(t, err, "failed to establish session pair")

s0.SetReliabilityParams(false, ReliabilityTypeRexmit, 0)

chunkTypes := captureChunkTypes(br, 0)

br.DropNextNWrites(0, 1)

sbuf := make([]byte, 1000)

binary.BigEndian.PutUint32(sbuf, uint32(0))

n, err := s0.WriteSCTP(sbuf, PayloadTypeWebRTCBinary)

require.NoError(t, err)

require.Equal(t, len(sbuf), n, "unexpected length of written data")

binary.BigEndian.PutUint32(sbuf, uint32(1))

n, err = s0.WriteSCTP(sbuf, PayloadTypeWebRTCBinary)

require.NoError(t, err)

require.Equal(t, len(sbuf), n, "unexpected length of written data")

flushBuffers(br, a0, a1)

requireEventuallyChunkType(t, chunkTypes, tt.expectedForwardType)

buf := make([]byte, 2000)

n, ppi, err := s1.ReadSCTP(buf)

require.NoError(t, err, "ReadSCTP failed")

require.Equal(t, PayloadTypeWebRTCBinary, ppi)

require.Equal(t, uint32(1), binary.BigEndian.Uint32(buf[:n]), "unexpected received data")

})

}

}

func TestAssociationInterleavingNegotiationPayloadChunkType(t *testing.T) {

tests := []struct {

name string

clientInterleaving bool

serverInterleaving bool

useInterleaving bool

expectedPayloadType chunkType

}{

{

name: "enabled enabled uses I-DATA",

clientInterleaving: true,

serverInterleaving: true,

useInterleaving: true,

expectedPayloadType: ctIData,

},

{

name: "enabled disabled uses DATA",

clientInterleaving: true,

serverInterleaving: false,

useInterleaving: false,

expectedPayloadType: ctPayloadData,

},

{

name: "disabled enabled uses DATA",

clientInterleaving: false,

serverInterleaving: true,

useInterleaving: false,

expectedPayloadType: ctPayloadData,

},

{

name: "disabled disabled uses DATA",

clientInterleaving: false,

serverInterleaving: false,

useInterleaving: false,

expectedPayloadType: ctPayloadData,

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

lim := test.TimeOut(time.Second * 10)

defer lim.Stop()

const si uint16 = 1

const msg = "ABC"

br := test.NewBridge()

a0, a1, err := createNewAssociationPairWithInterleaving(

br,

ackModeNoDelay,

0,

tt.clientInterleaving,

tt.serverInterleaving,

)

require.NoError(t, err, "failed to create associations")

defer closeAssociationPair(br, a0, a1)

require.Equal(t, tt.useInterleaving, a0.useInterleaving)

require.Equal(t, tt.useInterleaving, a1.useInterleaving)

metadata0, ok := a0.Metadata()

require.True(t, ok)

require.Equal(t, tt.useInterleaving, metadata0.MessageInterleavingEnabled)

require.False(t, metadata0.ZeroChecksumSendingEnabled)

require.False(t, metadata0.ZeroChecksumReceivingEnabled)

if tt.useInterleaving {

require.Equal(t, PartialReliabilityModeIForwardTSN, metadata0.PartialReliabilityMode)

} else {

require.Equal(t, PartialReliabilityModeForwardTSN, metadata0.PartialReliabilityMode)

}

metadata1, ok := a1.Metadata()

require.True(t, ok)

require.Equal(t, metadata0, metadata1)

s0, s1, err := establishSessionPair(br, a0, a1, si)

require.NoError(t, err, "failed to establish session pair")

chunkTypes := capturePayloadChunkTypes(br, 0)

n, err := s0.WriteSCTP([]byte(msg), PayloadTypeWebRTCBinary)

require.NoError(t, err)

require.Equal(t, len(msg), n)

flushBuffers(br, a0, a1)

requireNextPayloadChunkType(t, chunkTypes, tt.expectedPayloadType)

buf := make([]byte, 32)

n, ppi, err := s1.ReadSCTP(buf)

require.NoError(t, err, "ReadSCTP failed")

require.Equal(t, PayloadTypeWebRTCBinary, ppi)

require.Equal(t, msg, string(buf[:n]))

})

}

}

func TestAssociationMetadataNotReadyBeforeHandshake(t *testing.T) {

assoc := createTestAssociation(t, Config{

NetConn: &dumbConn{},

})

metadata, ok := assoc.Metadata()

require.False(t, ok)

require.Equal(t, AssociationMetadata{}, metadata)

}

func TestAssociationMetadataJSON(t *testing.T) {

metadata := AssociationMetadata{

MessageInterleavingEnabled: true,

PartialReliabilityMode: PartialReliabilityModeIForwardTSN,

ZeroChecksumSendingEnabled: true,

ZeroChecksumReceivingEnabled: true,

}

raw, err := json.Marshal(metadata)

require.NoError(t, err)

require.JSONEq(t, `{

"messageInterleavingEnabled": true,

"partialReliabilityMode": 2,

"zeroChecksumSendingEnabled": true,

"zeroChecksumReceivingEnabled": true

}`, string(raw))

}

func TestAssociationInterleavingProtocolViolationWrongPayloadChunkType(t *testing.T) {

tests := []struct {

name string

clientInterleaving bool

serverInterleaving bool

sendIData bool

expectedAbortReason string

}{

{

name: "DATA after interleaving negotiated",

clientInterleaving: true,

serverInterleaving: true,

sendIData: false,

expectedAbortReason: "received DATA with interleaving negotiated",

},

{

name: "I-DATA without interleaving negotiated",

clientInterleaving: true,

serverInterleaving: false,

sendIData: true,

expectedAbortReason: "received I-DATA without interleaving negotiated",

},

}

for _, tt := range tests {

t.Run(tt.name, func(t *testing.T) {

lim := test.TimeOut(time.Second * 10)

defer lim.Stop()

br := test.NewBridge()

a0, a1, err := createNewAssociationPairWithInterleaving(

br,

ackModeNoDelay,

0,

tt.clientInterleaving,

tt.serverInterleaving,

)

require.NoError(t, err, "failed to create associations")

defer closeAssociationPair(br, a0, a1)

reasons := captureProtocolViolationAborts(br, 1)

require.True(t, br.Push(marshalPayloadPacketFromAssociation(t, a0, tt.sendIData), 0))

requireProtocolViolationAbort(t, br, a1, reasons, tt.expectedAbortReason)

})

}

}

func TestAssociationInterleavingFinalizedOnEstablishedTransition(t *testing.T) {

t.Run("cookie ack", func(t *testing.T) {

assoc := createTestAssociation(t, Config{})

assoc.handshakeCompletedCh = make(chan error, 1)

assoc.localInterleaving = true

assoc.peerInterleaving = true

assoc.peerIForwardTSN = true

assoc.setState(cookieEchoed)

assoc.handleCookieAck()

require.Equal(t, established, assoc.getState())

require.True(t, assoc.useInterleaving)

require.True(t, assoc.useIForwardTSN)

require.False(t, assoc.useForwardTSN)

require.NoError(t, <-assoc.handshakeCompletedCh)

})

t.Run("cookie echo", func(t *testing.T) {

assoc := createTestAssociation(t, Config{})

assoc.handshakeCompletedCh = make(chan error, 1)

assoc.myCookie = &paramStateCookie{cookie: []byte("cookie")}

assoc.localInterleaving = true

assoc.peerInterleaving = true

assoc.peerIForwardTSN = true

assoc.setState(cookieEchoed)

packets := assoc.handleCookieEcho(&chunkCookieEcho{cookie: []byte("cookie")})

require.NotEmpty(t, packets)

require.Equal(t, established, assoc.getState())

require.True(t, assoc.useInterleaving)

require.True(t, assoc.useIForwardTSN)

require.False(t, assoc.useForwardTSN)

require.NoError(t, <-assoc.handshakeCompletedCh)

})

}

func TestAssociationDataIgnoredBeforeEstablished(t *testing.T) {

assoc := createTestAssociation(t, Config{})

assoc.localInterleaving = true

assoc.peerInterleaving = true

assoc.useInterleaving = false

assoc.payloadQueue.init(0)

assoc.setState(cookieEchoed)

packets := assoc.handleData(&chunkPayloadData{

iData: true,

messageIdentifier: 1,

fragmentSequenceNumber: 0,

beginningFragment: true,

endingFragment: true,

tsn: 1,

streamIdentifier: 1,

payloadType: PayloadTypeWebRTCBinary,

userData: []byte("pre-established"),

})

require.Nil(t, packets)

require.False(t, assoc.willSendAbort)

require.Equal(t, uint32(0), assoc.peerLastTSN())

require.Zero(t, assoc.stats.getNumDATAs())

}

func TestAssociationInterleavingProtocolViolationWrongForwardTSNChunkType(t *testing.T) {

tests := []struct {

name string

clientInterleaving bool

serverInterleaving bool

forwardTSNChunk chunk

expectedAbortReason string

}{

{

name: "FORWARD-TSN after interleaving negotiated",

clientInterleaving: true,

serverInterleaving: true,