av/rtmp/amf/amf_test.go

/*
NAME
  amf_test.go

DESCRIPTION
  AMF test suite.

AUTHORS
  Saxon Nelson-Milton <saxon@ausocean.org>
  Dan Kortschak <dan@ausocean.org>
  Alan Noble <alan@ausocean.org>

LICENSE
  amf_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 amf

import (
	"testing"
)

// Test data.
var testStrings = [...]string{
	"",
	"foo",
	"bar",
	"bazz",
}

var testNumbers = [...]int32{
	0,
	1,
	0xababab,
	0xffffff,
}

// TestSanity checks that we haven't accidentally changed constants.
func TestSanity(t *testing.T) {
	if TypeObjectEnd != 0x09 {
		t.Errorf("TypeObjectEnd has wrong value; got %d, expected %d", TypeObjectEnd, 0x09)
	}
}

// TestStrings tests string encoding and decoding.
func TestStrings(t *testing.T) {
	for _, s := range testStrings {
		// Short string encoding is as follows:
		//   enc[0]   = data type (typeString)
		//   end[1:3] = size
		//   enc[3:]  = data
		buf := make([]byte, len(s)+5)
		_, err := EncodeString(buf, s)
		if err != nil {
			t.Errorf("EncodeString failed")
		}
		if buf[0] != typeString {
			t.Errorf("Expected typeString, got %v", buf[0])
		}
		ds := DecodeString(buf[1:])
		if s != ds {
			t.Errorf("DecodeString did not produce original string, got %v", ds)
		}
	}
}

// TestNumbers tests 24-bit encoding and encoding.
// We don't test the others as they are just wrappers for standard functions in encoding/binary.
func TestNumbers(t *testing.T) {
	for _, n := range testNumbers {
		buf := make([]byte, 4) // NB: encoder requires an extra byte for some reason
		_, err := EncodeInt24(buf, n)
		if err != nil {
			t.Errorf("EncodeInt24 failed")
		}
		dn := int32(DecodeInt24(buf))
		if n != dn {
			t.Errorf("DecodeInt24 did not produce original number, got %v", dn)
		}
	}
}

// TestProperties tests encoding and decoding of properties.
func TestProperties(t *testing.T) {
	var buf [1024]byte

	// Encode/decode number properties.
	enc := buf[:]
	var err error
	for i, _ := range testNumbers {
		enc, err = PropEncode(&Property{dtype: typeNumber, number: float64(testNumbers[i])}, enc)
		if err != nil {
			t.Errorf("PropEncode of number failed")
		}

	}
	var n int32
	prop := Property{}
	dec := buf[:]
	for i, _ := range testNumbers {
		n = PropDecode(&prop, dec, 0)
		if n < 0 {
			t.Errorf("PropDecode of number failed")
		}
		if int32(prop.number) != testNumbers[i] {
			t.Errorf("PropEncode/PropDecode returned wrong number; got %v, expected %v", int32(prop.number), testNumbers[i])
		}
		dec = dec[n:]
	}

	// Encode/decode string properties.
	enc = buf[:]
	for i, _ := range testStrings {
		enc, err = PropEncode(&Property{dtype: typeString, str: testStrings[i]}, enc)
		if err != nil {
			t.Errorf("PropEncode of string failed")
		}

	}
	prop = Property{}
	dec = buf[:]
	for i, _ := range testStrings {
		n = PropDecode(&prop, dec, 0)
		if n < 0 {
			t.Errorf("PropDecode of string failed")
		}
		if prop.str != testStrings[i] {
			t.Errorf("PropEncode/PropDecode returned wrong string; got %s, expected %s", prop.str, testStrings[i])
		}
		dec = dec[n:]
	}

}

// TestObject tests encoding and decoding of objects.
func TestObject(t *testing.T) {
	var buf [1024]byte

	// Construct a simple object that has one property, the number 42.
	prop1 := Property{dtype: typeNumber, number: 42}
	obj1 := Object{}
	obj1.Props = append(obj1.Props, prop1)

	// Encode it
	enc := buf[:]
	var err error
	enc, err = Encode(&obj1, enc)
	if err != nil {
		t.Errorf("Encode of object failed")
	}

	// Check the encoding
	if uint8(buf[0]) != TypeObject {
		t.Errorf("Encoded wrong type; expected %d, got %v", TypeObject, uint8(buf[0]))
	}
	if uint8(buf[1]) != typeNumber {
		t.Errorf("Encoded wrong type; expected %d, got %v", typeNumber, uint8(buf[0]))
	}
	num := DecodeNumber(buf[2:10])
	if num != 42 {
		t.Errorf("Encoded wrong number")
	}
	end := int32(DecodeInt24(buf[10:13]))
	if end != TypeObjectEnd {
		t.Errorf("Did not encode TypeObjectEnd")
	}

	// Decode it
	dec := buf[1:]
	var dobj1 Object
	n := Decode(&dobj1, dec, 0)
	if n < 0 {
		t.Errorf("Decode of object failed")
	}

	// Construct a more complicated object.
	var obj2 Object
	for i, _ := range testStrings {
		obj2.Props = append(obj2.Props, Property{dtype: typeString, str: testStrings[i]})
		obj2.Props = append(obj2.Props, Property{dtype: typeNumber, number: float64(testNumbers[i])})
	}

	// Encode it.
	enc = buf[:]
	enc, err = Encode(&obj2, enc)
	if err != nil {
		t.Errorf("Encode of object failed")
	}

	// Decode it.
	dec = buf[1:]
	var dobj2 Object
	n = Decode(&dobj2, dec, 0)
	if n < 0 {
		t.Errorf("Decode of object failed")
	}
}