mirror of https://bitbucket.org/ausocean/av.git
261 lines
6.5 KiB
Go
261 lines
6.5 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
|
|
const (
|
|
gpsTstStr1 = "$GPGGA,123519,4807.038,N,01131.000,E,1,08,0.9,545.4,M,46.9,M,,*47"
|
|
gpsTstStr2 = "$GPGGA,183710,4902.048,N,02171.020,E,1,09,0.5,547.2,M,43.4,M,,*42"
|
|
)
|
|
|
|
// 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 (
|
|
pmtTimeGpsBytesPart1 = []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(gpsDescTag), // Descriptor tag for gps
|
|
byte(gpsDataSize), // Length of bytes to follow
|
|
}
|
|
pmtTimeGpsBytesPart2 = []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 gps1
|
|
pmtTimeGpsBytes1 = buildPmtTimeGpsBytes(gpsTstStr1)
|
|
|
|
// bytes representing pmt with with time1 and gps 2
|
|
pmtTimeGpsBytes2 = buildPmtTimeGpsBytes(gpsTstStr2)
|
|
)
|
|
|
|
// 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 gps
|
|
{
|
|
name: "pmt Bytes() with time and gps",
|
|
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(gpsDescTag),
|
|
Dl: byte(gpsDataSize),
|
|
Dd: GpsStrBytes(gpsTstStr1),
|
|
},
|
|
},
|
|
Essd: &ESSD{
|
|
St: 0x1b,
|
|
Epid: 0x0100,
|
|
Esil: 0x00,
|
|
},
|
|
},
|
|
},
|
|
},
|
|
want: buildPmtTimeGpsBytes(gpsTstStr1),
|
|
},
|
|
}
|
|
|
|
// 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()
|
|
// Remove crc32s
|
|
got = got[:len(got)-4]
|
|
if !bytes.Equal(got, 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)
|
|
err := UpdateTime(cpy, tstTime2)
|
|
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 := TimeOf(pmtTimeBytes1)
|
|
if err != nil {
|
|
t.Errorf("Getting timestamp failed with err: %v", err)
|
|
}
|
|
if s != tstTime1 {
|
|
t.Errorf(errCmp, "TestTimeGet", tstTime1, s)
|
|
}
|
|
}
|
|
|
|
// TestGpsUpdate checks to see if we can update the gps string in a pmt correctly
|
|
func TestGpsUpdate(t *testing.T) {
|
|
cpy := make([]byte, len(pmtTimeGpsBytes1))
|
|
copy(cpy, pmtTimeGpsBytes1)
|
|
err := UpdateGps(cpy, gpsTstStr2)
|
|
if err != nil {
|
|
t.Errorf("Update time returned err: %v", err)
|
|
}
|
|
if !bytes.Equal(pmtTimeGpsBytes2, cpy) {
|
|
t.Errorf(errCmp, "TestGpsUpdate", pmtTimeGpsBytes2, cpy)
|
|
}
|
|
}
|
|
|
|
// buildPmtTimeGpsBytes is a helper function to help construct the byte slices
|
|
// for pmts with time and gps, as the gps data field is 32 bytes, i.e. quite large
|
|
// to type out
|
|
func buildPmtTimeGpsBytes(tstStr string) []byte {
|
|
return append(append(append(make([]byte, 0), pmtTimeGpsBytesPart1...),
|
|
GpsStrBytes(tstStr)...), pmtTimeGpsBytesPart2...)
|
|
}
|