av/stream/mts/psi/psi_test.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...)
}