av/protocol/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 = [...]uint32{
	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) {
	// Short string encoding is as follows:
	//   enc[0]   = data type (TypeString)
	//   end[1:3] = size
	//   enc[3:]  = data
	for _, s := range testStrings {
		buf := make([]byte, len(s)+7)
		_, 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)
		}
	}
	// Long string encoding is as follows:
	//   enc[0]   = data type (TypeString)
	//   end[1:5] = size
	//   enc[5:]  = data
	s := string(make([]byte, 65536))
	buf := make([]byte, len(s)+7)
	_, err := EncodeString(buf, s)
	if err != nil {
		t.Errorf("EncodeString failed")
	}
	if buf[0] != typeLongString {
		t.Errorf("Expected typeLongString, got %v", buf[0])
	}
	ds := DecodeLongString(buf[1:])
	if s != ds {
		t.Errorf("DecodeLongString did not produce original string, got %v", ds)
	}
}

// TestNumbers tests number encoding and encoding.
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 := DecodeInt24(buf)
		if n != dn {
			t.Errorf("DecodeInt24 did not produce original Number, got %v", dn)
		}
		_, err = EncodeInt32(buf, n)
		if err != nil {
			t.Errorf("EncodeInt32 failed")
		}
		dn = DecodeInt32(buf)
		if n != dn {
			t.Errorf("DecodeInt32 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 = EncodeProperty(&Property{Type: typeNumber, Number: float64(testNumbers[i])}, enc)
		if err != nil {
			t.Errorf("EncodeProperty of Number failed")
		}

	}

	prop := Property{}
	dec := buf[:]
	for i := range testNumbers {
		n, err := DecodeProperty(&prop, dec, false)
		if err != nil {
			t.Errorf("DecodeProperty of Number failed")
		}
		if prop.Number != float64(testNumbers[i]) {
			t.Errorf("EncodeProperty/DecodeProperty 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 = EncodeProperty(&Property{Type: TypeString, String: testStrings[i]}, enc)
		if err != nil {
			t.Errorf("EncodeProperty of string failed")
		}

	}
	prop = Property{}
	dec = buf[:]
	for i := range testStrings {
		n, err := DecodeProperty(&prop, dec, false)
		if err != nil {
			t.Errorf("DecodeProperty of string failed")
		}
		if prop.String != testStrings[i] {
			t.Errorf("EncodeProperty/DecodeProperty returned wrong string; got %s, expected %s", prop.String, 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{Type: typeNumber, Number: 42}
	obj1 := Object{}
	obj1.Properties = append(obj1.Properties, 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 buf[0] != TypeObject {
		t.Errorf("Encoded wrong type; expected %d, got %v", TypeObject, buf[0])
	}
	if buf[1] != typeNumber {
		t.Errorf("Encoded wrong type; expected %d, got %v", typeNumber, 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
	_, err = Decode(&dobj1, dec, false)
	if err != nil {
		t.Errorf("Decode of object failed")
	}

	// Change the object's property to a named boolean.
	obj1.Properties[0].Name = "on"
	obj1.Properties[0].Type = typeBoolean
	obj1.Properties[0].Number = 1

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

	// Decode it, this time with named set to true.
	dec = buf[1:]
	_, err = Decode(&dobj1, dec, true)
	if err != nil {
		t.Errorf("Decode of object failed with error: %v", err)
	}
	if dobj1.Properties[0].Number != 1 {
		t.Errorf("Decoded wrong boolean value")
	}

	// Construct a more complicated object that includes a nested object.
	var obj2 Object
	for i := range testStrings {
		obj2.Properties = append(obj2.Properties, Property{Type: TypeString, String: testStrings[i]})
		obj2.Properties = append(obj2.Properties, Property{Type: typeNumber, Number: float64(testNumbers[i])})
	}
	obj2.Properties = append(obj2.Properties, Property{Type: TypeObject, Object: obj1})
	obj2.Properties = append(obj2.Properties, Property{Type: typeBoolean, Number: 1})

	// Retrieve nested object
	obj, err := obj2.ObjectProperty("", 8)
	if err != err {
		t.Errorf("Failed to retrieve object")
	}
	if len(obj.Properties) < 1 {
		t.Errorf("Properties missing for nested object")
	}
	if obj.Properties[0].Type != typeBoolean {
		t.Errorf("Wrong property type for nested object")
	}

	// 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
	_, err = Decode(&dobj2, dec, false)
	if err != nil {
		t.Errorf("Decode of object failed with error: %v", err)
	}

	// Find some properties that exist.
	s, err := obj2.StringProperty("", 2)
	if err != nil {
		t.Errorf("StringProperty failed")
	}
	if s != "foo" {
		t.Errorf("StringProperty returned wrong String")
	}
	n, err := obj2.NumberProperty("", 3)
	if err != nil {
		t.Errorf("NumberProperty failed")
	}
	if n != 1 {
		t.Errorf("NumberProperty returned wrong Number")
	}
	obj, err = obj2.ObjectProperty("", 8)
	if err != nil {
		t.Errorf("ObjectProperty failed")
		return
	}
	if obj.Properties[0].Type != typeBoolean {
		t.Errorf("ObjectProperty returned object with wrong property")
	}
	prop, err := obj2.Property("", 9, typeBoolean)
	if err != nil {
		t.Errorf("Property failed")
		return
	}
	if prop.Number != 1 {
		t.Errorf("Property returned wrong Property")
	}

	// Try to find one that doesn't exist.
	prop, err = obj2.Property("", 10, TypeObject)
	if err != ErrPropertyNotFound {
		t.Errorf("Property(10) failed")
	}
}