package/gortsplib
1
0
Fork 0
mirror of https://github.com/aler9/gortsplib synced 2025-10-05 15:16:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

improve tests

Browse Source
This commit is contained in:
aler9
2022-06-11 19:19:38 +02:00
parent 92ed04ad6c
commit 4e41b1c88b
3 changed files with 128 additions and 305 deletions
Download Patch File Download Diff File Expand all files Collapse all files

194
client_read_test.go
View File

@@ -2,7 +2,6 @@ package gortsplib
import (
"bufio"
"bytes"
"crypto/tls"
"fmt"
"net"
@@ -22,22 +21,6 @@ import (
"github.com/aler9/gortsplib/pkg/url"
)
func mergeBytes(vals ...[]byte) []byte {
size := 0
for _, v := range vals {
size += len(v)
}
res := make([]byte, size)
pos := 0
for _, v := range vals {
n := copy(res[pos:], v)
pos += n
}
return res
}
func TestClientReadTracks(t *testing.T) {
track1, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err)
@@ -443,183 +426,6 @@ func TestClientRead(t *testing.T) {
}
}
var oversizedPacketRTPIn = rtp.Packet{
Header: rtp.Header{
Version: 2,
PayloadType: 96,
Marker: true,
SequenceNumber: 34572,
},
Payload: bytes.Repeat([]byte{0x01, 0x02, 0x03, 0x04, 0x05}, 4096/5),
}
var oversizedPacketsRTPOut = []rtp.Packet{
{
Header: rtp.Header{
Version: 2,
PayloadType: 96,
Marker: false,
SequenceNumber: 34572,
},
Payload: mergeBytes(
[]byte{0x1c, 0x81, 0x02, 0x03, 0x04, 0x05},
bytes.Repeat([]byte{0x01, 0x02, 0x03, 0x04, 0x05}, 290),
[]byte{0x01, 0x02, 0x03, 0x04},
),
},
{
Header: rtp.Header{
Version: 2,
PayloadType: 96,
Marker: false,
SequenceNumber: 34573,
},
Payload: mergeBytes(
[]byte{0x1c, 0x01, 0x05},
bytes.Repeat([]byte{0x01, 0x02, 0x03, 0x04, 0x05}, 291),
[]byte{0x01, 0x02},
),
},
{
Header: rtp.Header{
Version: 2,
PayloadType: 96,
Marker: true,
SequenceNumber: 34574,
},
Payload: mergeBytes(
[]byte{0x1c, 0x41, 0x03, 0x04, 0x05},
bytes.Repeat([]byte{0x01, 0x02, 0x03, 0x04, 0x05}, 235),
),
},
}
func TestClientReadOversizedPacket(t *testing.T) {
oversizedPacketsRTPOut := append([]rtp.Packet(nil), oversizedPacketsRTPOut...)
l, err := net.Listen("tcp", "localhost:8554")
require.NoError(t, err)
defer l.Close()
serverDone := make(chan struct{})
defer func() { <-serverDone }()
go func() {
defer close(serverDone)
conn, err := l.Accept()
require.NoError(t, err)
defer conn.Close()
br := bufio.NewReader(conn)
req, err := readRequest(br)
require.NoError(t, err)
require.Equal(t, base.Options, req.Method)
require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
byts, _ := base.Response{
StatusCode: base.StatusOK,
Header: base.Header{
"Public": base.HeaderValue{strings.Join([]string{
string(base.Describe),
string(base.Setup),
string(base.Play),
}, ", ")},
},
}.Write()
_, err = conn.Write(byts)
require.NoError(t, err)
req, err = readRequest(br)
require.NoError(t, err)
require.Equal(t, base.Describe, req.Method)
require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream"), req.URL)
track, err := NewTrackH264(96, []byte{0x01, 0x02, 0x03, 0x04}, []byte{0x01, 0x02, 0x03, 0x04}, nil)
require.NoError(t, err)
tracks := Tracks{track}
tracks.setControls()
byts, _ = base.Response{
StatusCode: base.StatusOK,
Header: base.Header{
"Content-Type": base.HeaderValue{"application/sdp"},
"Content-Base": base.HeaderValue{"rtsp://localhost:8554/teststream/"},
},
Body: tracks.Write(false),
}.Write()
_, err = conn.Write(byts)
require.NoError(t, err)
req, err = readRequest(br)
require.NoError(t, err)
require.Equal(t, base.Setup, req.Method)
require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream/trackID=0"), req.URL)
th := headers.Transport{
Delivery: func() *headers.TransportDelivery {
v := headers.TransportDeliveryUnicast
return &v
}(),
Protocol: headers.TransportProtocolTCP,
InterleavedIDs: &[2]int{0, 1},
}
byts, _ = base.Response{
StatusCode: base.StatusOK,
Header: base.Header{
"Transport": th.Write(),
},
}.Write()
_, err = conn.Write(byts)
require.NoError(t, err)
req, err = readRequest(br)
require.NoError(t, err)
require.Equal(t, base.Play, req.Method)
require.Equal(t, mustParseURL("rtsp://localhost:8554/teststream/"), req.URL)
require.Equal(t, base.HeaderValue{"npt=0-"}, req.Header["Range"])
byts, _ = base.Response{
StatusCode: base.StatusOK,
}.Write()
_, err = conn.Write(byts)
require.NoError(t, err)
byts, _ = oversizedPacketRTPIn.Marshal()
byts, _ = base.InterleavedFrame{
Channel: 0,
Payload: byts,
}.Write()
_, err = conn.Write(byts)
require.NoError(t, err)
}()
packetRecv := make(chan struct{})
c := &Client{
Transport: func() *Transport {
v := TransportTCP
return &v
}(),
OnPacketRTP: func(ctx *ClientOnPacketRTPCtx) {
require.Equal(t, 0, ctx.TrackID)
cmp := oversizedPacketsRTPOut[0]
oversizedPacketsRTPOut = oversizedPacketsRTPOut[1:]
require.Equal(t, &cmp, ctx.Packet)
if len(oversizedPacketsRTPOut) == 0 {
close(packetRecv)
}
},
}
err = c.StartReading("rtsp://localhost:8554/teststream")
require.NoError(t, err)
defer c.Close()
<-packetRecv
}
func TestClientReadPartial(t *testing.T) {
listenIP := multicastCapableIP(t)
l, err := net.Listen("tcp", listenIP+":8554")