mirror of https://bitbucket.org/ausocean/av.git
126 lines
3.0 KiB
Go
126 lines
3.0 KiB
Go
/*
|
|
NAME
|
|
client_test.go
|
|
|
|
DESCRIPTION
|
|
client_test.go provides testing utilities to check RTP client functionality
|
|
provided in client.go.
|
|
|
|
AUTHOR
|
|
Saxon A. Nelson-Milton <saxon@ausocean.org>
|
|
|
|
LICENSE
|
|
This is Copyright (C) 2019 the Australian Ocean Lab (AusOcean).
|
|
|
|
It is free software: you can redistribute it and/or modify them
|
|
under the terms of the GNU General Public License as published by the
|
|
Free Software Foundation, either version 3 of the License, or (at your
|
|
option) any later version.
|
|
|
|
It is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
in gpl.txt. If not, see http://www.gnu.org/licenses.
|
|
*/
|
|
|
|
package rtp
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"io"
|
|
"net"
|
|
"testing"
|
|
)
|
|
|
|
// TestReceive checks that the Client can correctly receive RTP packets and
|
|
// perform a specificed operation on the packets before storing in the ringBuffer.
|
|
func TestReceive(t *testing.T) {
|
|
const (
|
|
clientAddr = "localhost:8000"
|
|
packetsToSend = 20
|
|
)
|
|
|
|
testErr := make(chan error)
|
|
serverErr := make(chan error)
|
|
done := make(chan struct{})
|
|
clientReady := make(chan struct{})
|
|
var c *Client
|
|
|
|
// Start routine to read from client.
|
|
go func() {
|
|
// Create and start the client.
|
|
var err error
|
|
c, err = NewClient(clientAddr)
|
|
if err != nil {
|
|
testErr <- fmt.Errorf("could not create client, failed with error: %v\n", err)
|
|
}
|
|
close(clientReady)
|
|
|
|
// Read packets using the client and check them with expected.
|
|
var packetsReceived int
|
|
buf := make([]byte, 4096)
|
|
for packetsReceived != packetsToSend {
|
|
n, err := c.Read(buf)
|
|
switch err {
|
|
case nil:
|
|
case io.EOF:
|
|
continue
|
|
default:
|
|
testErr <- fmt.Errorf("unexpected error from c.Read: %v\n", err)
|
|
}
|
|
|
|
// Create expected data and apply operation if there is one.
|
|
expect := (&Packet{V: rtpVer, Payload: []byte{byte(packetsReceived)}}).Bytes(nil)
|
|
|
|
// Compare.
|
|
got := buf[:n]
|
|
if !bytes.Equal(got, expect) {
|
|
testErr <- fmt.Errorf("did not get expected result. \nGot: %v\n Want: %v\n", got, expect)
|
|
}
|
|
packetsReceived++
|
|
}
|
|
close(done)
|
|
}()
|
|
|
|
// Start the RTP server.
|
|
go func() {
|
|
<-clientReady
|
|
cAddr, err := net.ResolveUDPAddr("udp", clientAddr)
|
|
if err != nil {
|
|
serverErr <- fmt.Errorf("could not resolve server address, failed with err: %v\n", err)
|
|
}
|
|
|
|
conn, err := net.DialUDP("udp", nil, cAddr)
|
|
if err != nil {
|
|
serverErr <- fmt.Errorf("could not dial udp, failed with err: %v\n", err)
|
|
}
|
|
|
|
// Send packets to the client.
|
|
for i := 0; i < packetsToSend; i++ {
|
|
p := (&Packet{V: rtpVer, Payload: []byte{byte(i)}}).Bytes(nil)
|
|
_, err := conn.Write(p)
|
|
if err != nil {
|
|
serverErr <- fmt.Errorf("could not write packet to conn, failed with err: %v\n", err)
|
|
}
|
|
}
|
|
}()
|
|
|
|
<-clientReady
|
|
loop:
|
|
for {
|
|
select {
|
|
case err := <-testErr:
|
|
t.Fatal(err)
|
|
case err := <-serverErr:
|
|
t.Fatal(err)
|
|
case <-done:
|
|
break loop
|
|
default:
|
|
}
|
|
}
|
|
}
|