mirror of https://bitbucket.org/ausocean/av.git
280 lines
7.2 KiB
Go
280 lines
7.2 KiB
Go
/*
|
|
NAME
|
|
psi_test.go
|
|
DESCRIPTION
|
|
See Readme.md
|
|
|
|
AUTHOR
|
|
Saxon Milton <saxon@ausocean.org>
|
|
|
|
LICENSE
|
|
psi_test.go is Copyright (C) 2018 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
|
|
along with revid in gpl.txt. If not, see http://www.gnu.org/licenses.
|
|
*/
|
|
|
|
package psi
|
|
|
|
import (
|
|
"bytes"
|
|
"testing"
|
|
)
|
|
|
|
// Times as ints for testing
|
|
const (
|
|
tstTime1 = 1235367435 // 0x49A2360B
|
|
tstTime2 = 1735357535 // 0x676F745F
|
|
)
|
|
|
|
// GPS string for testing
|
|
// TODO: make these realistic
|
|
const (
|
|
locationTstStr1 = "$GPGGA,123519,4807.038,N,01131.0"
|
|
locationTstStr2 = "$GPGGA,183710,4902.048,N,02171.0"
|
|
)
|
|
|
|
// err message
|
|
const (
|
|
errCmp = "Incorrect output, for: %v wanted: %v, got: %v"
|
|
)
|
|
|
|
// Test time to bytes test Data
|
|
var (
|
|
timeSlice = []byte{
|
|
0x00, 0x00, 0x00, 0x00, 0x49, 0xA2, 0x36, 0x0B,
|
|
}
|
|
)
|
|
|
|
// Parts to construct bytes of pmt with time and bytes
|
|
var (
|
|
pmtTimeLocationBytesPart1 = []byte{
|
|
0x00, 0x02, 0xb0, 0x12, 0x00, 0x01, 0xc1, 0x00, 0x00, 0xe1, 0x00, 0xf0, 0x0a,
|
|
byte(timeDescTag), // Descriptor tag for timestamp
|
|
byte(timeDataSize), // Length of bytes to follow
|
|
0x00, 0x00, 0x00, 0x00, 0x67, 0x6F, 0x74, 0x5F, // Timestamp data
|
|
byte(locationDescTag), // Descriptor tag for location
|
|
byte(locationDataSize), // Length of bytes to follow
|
|
}
|
|
pmtTimeLocationBytesPart2 = []byte{
|
|
0x1b, 0xe1, 0x00, 0xf0, 0x00,
|
|
}
|
|
)
|
|
|
|
var (
|
|
// Bytes representing pmt with tstTime1
|
|
pmtTimeBytes1 = []byte{
|
|
0x00, 0x02, 0xb0, 0x12, 0x00, 0x01, 0xc1, 0x00, 0x00, 0xe1, 0x00, 0xf0, 0x0a,
|
|
byte(timeDescTag), // Descriptor tag
|
|
byte(timeDataSize), // Length of bytes to follow
|
|
0x00, 0x00, 0x00, 0x00, 0x49, 0xA2, 0x36, 0x0B, // timestamp
|
|
0x1b, 0xe1, 0x00, 0xf0, 0x00,
|
|
}
|
|
|
|
// Bytes representing pmt with tstTime 2
|
|
pmtTimeBytes2 = []byte{
|
|
0x00, 0x02, 0xb0, 0x12, 0x00, 0x01, 0xc1, 0x00, 0x00, 0xe1, 0x00, 0xf0, 0x0a,
|
|
byte(timeDescTag), // Descriptor tag
|
|
byte(timeDataSize), // Length of bytes to follow
|
|
0x00, 0x00, 0x00, 0x00, 0x67, 0x6F, 0x74, 0x5F, // timestamp
|
|
0x1b, 0xe1, 0x00, 0xf0, 0x00,
|
|
}
|
|
|
|
// Bytes representing pmt with time1 and location1
|
|
pmtTimeLocBytes1 = buildPmtTimeLocBytes(locationTstStr1)
|
|
|
|
// bytes representing pmt with with time1 and location 2
|
|
pmtTimeLocBytes2 = buildPmtTimeLocBytes(locationTstStr2)
|
|
)
|
|
|
|
// bytesTests contains data for testing the Bytes() funcs for the PSI data struct
|
|
var bytesTests = []struct {
|
|
name string
|
|
input PSI
|
|
want []byte
|
|
}{
|
|
// Pat test
|
|
{
|
|
name: "pat Bytes()",
|
|
input: StdPat,
|
|
want: StdPatBytes,
|
|
},
|
|
|
|
// Pmt test data no descriptor
|
|
{
|
|
name: "pmt to Bytes() without descriptors",
|
|
input: StdPmt,
|
|
want: StdPmtBytes,
|
|
},
|
|
|
|
// Pmt with time descriptor
|
|
{
|
|
name: "pmt to Bytes() with time descriptor",
|
|
input: PSI{
|
|
Pf: 0x00,
|
|
Tid: 0x02,
|
|
Ssi: true,
|
|
Sl: uint16(0x12),
|
|
Tss: &TSS{
|
|
Tide: uint16(0x01),
|
|
V: 0,
|
|
Cni: true,
|
|
Sn: 0,
|
|
Lsn: 0,
|
|
Sd: &PMT{
|
|
Pcrpid: 0x0100, // wrong
|
|
Pil: 10,
|
|
Pd: []Desc{
|
|
Desc{
|
|
Dt: byte(timeDescTag),
|
|
Dl: byte(timeDataSize),
|
|
Dd: TimeBytes(tstTime1),
|
|
},
|
|
},
|
|
Essd: &ESSD{
|
|
St: 0x1b,
|
|
Epid: 0x0100,
|
|
Esil: 0x00,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
want: pmtTimeBytes1,
|
|
},
|
|
|
|
// Pmt with time and location
|
|
{
|
|
name: "pmt Bytes() with time and location",
|
|
input: PSI{
|
|
Pf: 0x00,
|
|
Tid: 0x02,
|
|
Ssi: true,
|
|
Sl: uint16(0x12),
|
|
Tss: &TSS{
|
|
Tide: uint16(0x01),
|
|
V: 0,
|
|
Cni: true,
|
|
Sn: 0,
|
|
Lsn: 0,
|
|
Sd: &PMT{
|
|
Pcrpid: 0x0100, // wrong
|
|
Pil: 10,
|
|
Pd: []Desc{
|
|
Desc{
|
|
Dt: byte(timeDescTag),
|
|
Dl: byte(timeDataSize),
|
|
Dd: TimeBytes(tstTime2),
|
|
},
|
|
Desc{
|
|
Dt: byte(locationDescTag),
|
|
Dl: byte(locationDataSize),
|
|
Dd: LocationStrBytes(locationTstStr1),
|
|
},
|
|
},
|
|
Essd: &ESSD{
|
|
St: 0x1b,
|
|
Epid: 0x0100,
|
|
Esil: 0x00,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
want: buildPmtTimeLocBytes(locationTstStr1),
|
|
},
|
|
}
|
|
|
|
// TestBytes ensures that the Bytes() funcs are working correctly to take PSI
|
|
// structs and convert them to byte slices
|
|
func TestBytes(t *testing.T) {
|
|
for _, test := range bytesTests {
|
|
got := test.input.Bytes()
|
|
if !bytes.Equal(got, addPadding(addCrc(test.want))) {
|
|
t.Errorf("unexpected error for test %v: got:%v want:%v", test.name, got,
|
|
test.want)
|
|
}
|
|
}
|
|
}
|
|
|
|
// TestTimestampToBytes is a quick sanity check of the int64 time to []byte func
|
|
func TestTimestampToBytes(t *testing.T) {
|
|
tb := TimeBytes(tstTime1)
|
|
if !bytes.Equal(timeSlice, tb) {
|
|
t.Errorf(errCmp, "testTimeStampToBytes", timeSlice, tb)
|
|
}
|
|
}
|
|
|
|
// TestTimeUpdate checks to see if we can correctly update the timstamp in pmt
|
|
func TestTimeUpdate(t *testing.T) {
|
|
cpy := make([]byte, len(pmtTimeBytes1))
|
|
copy(cpy, pmtTimeBytes1)
|
|
cpy = addCrc(cpy)
|
|
err := UpdateTime(cpy, tstTime2)
|
|
cpy = cpy[:len(cpy)-4]
|
|
if err != nil {
|
|
t.Errorf("Update time returned err: %v", err)
|
|
}
|
|
if !bytes.Equal(pmtTimeBytes2, cpy) {
|
|
t.Errorf(errCmp, "TestTimeUpdate", pmtTimeBytes2, cpy)
|
|
}
|
|
}
|
|
|
|
// TestTimeGet tsts to see if we can correctly get the timestamp from a pmt
|
|
func TestTimeGet(t *testing.T) {
|
|
s, err := TimeFrom(pmtTimeBytes1)
|
|
if err != nil {
|
|
t.Errorf("Getting timestamp failed with err: %v", err)
|
|
}
|
|
if s != tstTime1 {
|
|
t.Errorf(errCmp, "TestTimeGet", tstTime1, s)
|
|
}
|
|
}
|
|
|
|
// TestLocationGet checks that we can correctly get location data from a pmt table
|
|
func TestLocationGet(t *testing.T) {
|
|
pb := StdPmtTimeLocation.Bytes()
|
|
err := UpdateLocation(pb, locationTstStr1)
|
|
if err != nil {
|
|
t.Errorf("Error for TestLocationGet UpdateLocation(pb, locationTstStr1): %v", err)
|
|
}
|
|
g, err := LocationFrom(pb)
|
|
if err != nil {
|
|
t.Errorf("Error for TestLocationGet LocationOf(pb): %v", err)
|
|
}
|
|
if g != locationTstStr1 {
|
|
t.Errorf(errCmp, "TestLocationGet", locationTstStr1, g)
|
|
}
|
|
}
|
|
|
|
// TestLocationUpdate checks to see if we can update the location string in a pmt correctly
|
|
func TestLocationUpdate(t *testing.T) {
|
|
cpy := make([]byte, len(pmtTimeLocBytes1))
|
|
copy(cpy, pmtTimeLocBytes1)
|
|
cpy = addCrc(cpy)
|
|
err := UpdateLocation(cpy, locationTstStr2)
|
|
cpy = cpy[:len(cpy)-4]
|
|
if err != nil {
|
|
t.Errorf("Update time returned err: %v", err)
|
|
}
|
|
if !bytes.Equal(pmtTimeLocBytes2, cpy) {
|
|
t.Errorf(errCmp, "TestLocationUpdate", pmtTimeLocBytes2, cpy)
|
|
}
|
|
}
|
|
|
|
// buildPmtTimeLocationBytes is a helper function to help construct the byte slices
|
|
// for pmts with time and location, as the location data field is 32 bytes, i.e. quite large
|
|
// to type out
|
|
func buildPmtTimeLocBytes(tstStr string) []byte {
|
|
return append(append(append(make([]byte, 0), pmtTimeLocationBytesPart1...),
|
|
LocationStrBytes(tstStr)...), pmtTimeLocationBytesPart2...)
|
|
}
|