mirror of https://bitbucket.org/ausocean/av.git
316 lines
8.3 KiB
Go
316 lines
8.3 KiB
Go
/*
|
|
NAME
|
|
descriptor_test.go
|
|
|
|
DESCRIPTION
|
|
See Readme.md
|
|
|
|
AUTHOR
|
|
Saxon Nelson-Milton <saxon@ausocean.org>
|
|
|
|
LICENSE
|
|
descriptor_test.go is Copyright (C) 2017-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
|
|
along with revid in gpl.txt. If not, see http://www.gnu.org/licenses.
|
|
*/
|
|
|
|
package psi
|
|
|
|
import (
|
|
"bytes"
|
|
"testing"
|
|
)
|
|
|
|
const (
|
|
errNotExpectedOut = "Did not get expected output: \ngot : %v, \nwant: %v"
|
|
errUnexpectedErr = "Unexpected error: %v\n"
|
|
)
|
|
|
|
var (
|
|
tstPsi1 = PSI{
|
|
Pf: 0x00,
|
|
Tid: 0x02,
|
|
Ssi: true,
|
|
Sl: 0x1c,
|
|
Tss: &TSS{
|
|
Tide: 0x01,
|
|
V: 0,
|
|
Cni: true,
|
|
Sn: 0,
|
|
Lsn: 0,
|
|
Sd: &PMT{
|
|
Pcrpid: 0x0100, // wrong
|
|
Pil: 10,
|
|
Pd: []Desc{
|
|
{
|
|
Dt: TimeDescTag,
|
|
Dl: TimeDataSize,
|
|
Dd: make([]byte, TimeDataSize),
|
|
},
|
|
},
|
|
Essd: &ESSD{
|
|
St: 0x1b,
|
|
Epid: 0x0100,
|
|
Esil: 0x00,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
tstPsi2 = PSI{
|
|
Pf: 0x00,
|
|
Tid: 0x02,
|
|
Ssi: true,
|
|
Sl: 0x12,
|
|
Tss: &TSS{
|
|
Tide: 0x01,
|
|
V: 0,
|
|
Cni: true,
|
|
Sn: 0,
|
|
Lsn: 0,
|
|
Sd: &PMT{
|
|
Pcrpid: 0x0100,
|
|
Pil: 0,
|
|
Essd: &ESSD{
|
|
St: 0x1b,
|
|
Epid: 0x0100,
|
|
Esil: 0x00,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
tstPsi3 = PSI{
|
|
Pf: 0x00,
|
|
Tid: 0x02,
|
|
Ssi: true,
|
|
Sl: 0x3e,
|
|
Tss: &TSS{
|
|
Tide: 0x01,
|
|
V: 0,
|
|
Cni: true,
|
|
Sn: 0,
|
|
Lsn: 0,
|
|
Sd: &PMT{
|
|
Pcrpid: 0x0100,
|
|
Pil: PmtTimeLocationPil,
|
|
Pd: []Desc{
|
|
{
|
|
Dt: TimeDescTag,
|
|
Dl: TimeDataSize,
|
|
Dd: make([]byte, TimeDataSize),
|
|
},
|
|
{
|
|
Dt: LocationDescTag,
|
|
Dl: LocationDataSize,
|
|
Dd: make([]byte, LocationDataSize),
|
|
},
|
|
},
|
|
Essd: &ESSD{
|
|
St: 0x1b,
|
|
Epid: 0x0100,
|
|
Esil: 0x00,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
)
|
|
|
|
var (
|
|
pmtTimeBytesResizedBigger = []byte{
|
|
0x00, 0x02, 0xb0, 0x1e, 0x00, 0x01, 0xc1, 0x00, 0x00, 0xe1, 0x00, 0xf0, 0x0c,
|
|
TimeDescTag, // Descriptor tag
|
|
0x0a, // Length of bytes to follow
|
|
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, // timestamp
|
|
0x1b, 0xe1, 0x00, 0xf0, 0x00,
|
|
}
|
|
|
|
pmtTimeBytesResizedSmaller = []byte{
|
|
0x00, 0x02, 0xb0, 0x1a, 0x00, 0x01, 0xc1, 0x00, 0x00, 0xe1, 0x00, 0xf0, 0x08,
|
|
TimeDescTag, // Descriptor tag
|
|
0x06, // Length of bytes to follow
|
|
0x01, 0x02, 0x03, 0x04, 0x05, 0x06, // timestamp
|
|
0x1b, 0xe1, 0x00, 0xf0, 0x00,
|
|
}
|
|
)
|
|
|
|
// TestHasDescriptorExists checks that PSIBytes.HasDescriptor performs as expected
|
|
// when the PSI we're interested in has the descriptor of interest. HasDescriptor
|
|
// should return the descriptor bytes.
|
|
// TODO: HasDescriptor also returns index of descriptor - we should check this.
|
|
func TestHasDescriptorExists(t *testing.T) {
|
|
p := PSIBytes(tstPsi3.Bytes())
|
|
_, got := p.HasDescriptor(LocationDescTag)
|
|
want := []byte{
|
|
LocationDescTag,
|
|
LocationDataSize,
|
|
}
|
|
want = append(want, make([]byte, LocationDataSize)...)
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
// TestHasDescriptorAbsent checks that PSIBytes.HasDescriptor performs as expected
|
|
// when the PSI does not have the descriptor of interest. HasDescriptor should
|
|
// return a nil slice and a negative index.
|
|
// TODO: check index here as well.
|
|
func TestHasDescriptorAbsent(t *testing.T) {
|
|
p := PSIBytes(tstPsi3.Bytes())
|
|
const fakeTag = 236
|
|
_, got := p.HasDescriptor(fakeTag)
|
|
var want []byte
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
// TestHasDescriptorNone checks that PSIBytes.HasDescriptor behaves as expected
|
|
// when the PSI does not have any descriptors. HasDescriptor should return a nil
|
|
// slice.
|
|
// TODO: again check index here.
|
|
func TestHasDescriptorNone(t *testing.T) {
|
|
p := PSIBytes(tstPsi2.Bytes())
|
|
_, got := p.HasDescriptor(LocationDescTag)
|
|
var want []byte
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
// TestProgramInfoLen checks that PSIBytes.ProgramInfoLen correctly extracts
|
|
// the program info length from a PSI.
|
|
func TestProgramInfoLen(t *testing.T) {
|
|
p := PSIBytes(tstPsi1.Bytes())
|
|
got := p.ProgramInfoLen()
|
|
want := 10
|
|
if got != want {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
// TestDescriptors checks that PSIBytes.descriptors correctly returns the descriptors
|
|
// from a PSI when descriptors exist.
|
|
func TestDescriptors(t *testing.T) {
|
|
p := PSIBytes(tstPsi1.Bytes())
|
|
got := p.descriptors()
|
|
want := []byte{
|
|
TimeDescTag,
|
|
TimeDataSize,
|
|
}
|
|
want = append(want, make([]byte, TimeDataSize)...)
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
// TestDescriptors checks that PSIBYtes.desriptors correctly returns nil when
|
|
// we try to get descriptors from a psi without any descriptors.
|
|
func TestDescriptorsNone(t *testing.T) {
|
|
p := PSIBytes(tstPsi2.Bytes())
|
|
got := p.descriptors()
|
|
var want []byte
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
// TestCreateDescriptorEmpty checks that PSIBytes.createDescriptor correctly adds
|
|
// a descriptor to the descriptors list in a PSI when it has no descriptors already.
|
|
func TestCreateDescriptorEmpty(t *testing.T) {
|
|
got := PSIBytes(tstPsi2.Bytes())
|
|
got.createDescriptor(TimeDescTag, make([]byte, TimeDataSize))
|
|
updateCrc(got[1:])
|
|
want := PSIBytes(tstPsi1.Bytes())
|
|
if !bytes.Equal(want, got) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
// TestCreateDescriptorNotEmpty checks that PSIBytes.createDescriptor correctly adds
|
|
// a descriptor to the descriptors list in a PSI when it already has one with
|
|
// a different tag.
|
|
func TestCreateDescriptorNotEmpty(t *testing.T) {
|
|
got := PSIBytes(tstPsi1.Bytes())
|
|
got.createDescriptor(LocationDescTag, make([]byte, LocationDataSize))
|
|
updateCrc(got[1:])
|
|
want := PSIBytes(tstPsi3.Bytes())
|
|
if !bytes.Equal(want, got) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
// TestAddDescriptorEmpty checks that PSIBytes.AddDescriptor correctly adds a descriptor
|
|
// when there are no other descriptors present in the PSI.
|
|
func TestAddDescriptorEmpty(t *testing.T) {
|
|
got := PSIBytes(tstPsi2.Bytes())
|
|
if err := got.AddDescriptor(TimeDescTag, make([]byte, TimeDataSize)); err != nil {
|
|
t.Errorf(errUnexpectedErr, err.Error())
|
|
}
|
|
want := PSIBytes(tstPsi1.Bytes())
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
// TestAddDescriptorNonEmpty checks that PSIBytes.AddDescriptor correctly adds a
|
|
// descriptor when there is already a descriptor of a differing type in a PSI.
|
|
func TestAddDescriptorNonEmpty(t *testing.T) {
|
|
got := PSIBytes(tstPsi1.Bytes())
|
|
if err := got.AddDescriptor(LocationDescTag, make([]byte, LocationDataSize)); err != nil {
|
|
t.Errorf(errUnexpectedErr, err.Error())
|
|
}
|
|
want := PSIBytes(tstPsi3.Bytes())
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
func TestAddDescriptorUpdateSame(t *testing.T) {
|
|
newData := [8]byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08}
|
|
want := PSIBytes(tstPsi2.Bytes())
|
|
want.createDescriptor(TimeDescTag, newData[:])
|
|
|
|
got := PSIBytes(tstPsi1.Bytes())
|
|
if err := got.AddDescriptor(TimeDescTag, newData[:]); err != nil {
|
|
t.Errorf(errUnexpectedErr, err.Error())
|
|
}
|
|
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
func TestAddDescriptorUpdateBigger(t *testing.T) {
|
|
got := PSIBytes(tstPsi1.Bytes())
|
|
if err := got.AddDescriptor(TimeDescTag, []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a}); err != nil {
|
|
t.Errorf(errUnexpectedErr, err.Error())
|
|
}
|
|
want := addCrc(pmtTimeBytesResizedBigger)
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|
|
|
|
func TestAddDescriptorUpdateSmaller(t *testing.T) {
|
|
got := PSIBytes(tstPsi1.Bytes())
|
|
if err := got.AddDescriptor(TimeDescTag, []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}); err != nil {
|
|
t.Errorf(errUnexpectedErr, err.Error())
|
|
}
|
|
want := addCrc(pmtTimeBytesResizedSmaller)
|
|
if !bytes.Equal(got, want) {
|
|
t.Errorf(errNotExpectedOut, got, want)
|
|
}
|
|
}
|