av/rtmp/rtmp_test.go

/*
NAME
  rtmp_test.go

DESCRIPTION
  See Readme.md

AUTHOR
  Saxon Nelson-Milton <saxon@ausocean.org>

LICENSE
  rtmp_test.go is Copyright (C) 2017 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 rtmp

import (
	"testing"
	"unsafe"
)

const (
	arrStart = 0
	arrEnd   = 5
	arrSize  = 6
	inc      = 3
	dec      = 3
)

const (
	byteSize  = 1
	int32Size = 4
	int64Size = 8
)

var (
	byteArr  = [arrSize]byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}
	int32Arr = [arrSize]int32{1, 2, 3, 4, 5, 6}
	int64Arr = [arrSize]int64{1, 2, 3, 4, 5, 6}
	errMsg   = "Obtained: %v, but wanted: %v"
)

// TODO: write test for realloc
// TODO: write test for memmove
// TODO: write test for allocate

func TestMemcmp(t *testing.T) {
	slice1 := []byte("ABCDEFG")
	slice2 := []byte("ABCDEFG")
	slice3 := []byte("ABCDJFG")

	if memcmp(unsafe.Pointer(&slice1[0]), unsafe.Pointer(&slice2[0]), 7) != 0 {
		t.Errorf("Should have got 0!")
	}

	if memcmp(unsafe.Pointer(&slice1[0]), unsafe.Pointer(&slice3[0]), 7) == 0 {
		t.Errorf("Should not have got 0!")
	}
}

func TestMemset(t *testing.T) {
	size := 10
	setNum := 5
	testVal := byte('A')
	mem := allocate(uintptr(size))
	memset((*byte)(mem), int(testVal), setNum)
	for i := 0; i < size; i++ {
		if i > setNum-1 {
			testVal = byte(0)
		}
		if *indxBytePtr(mem, i) != testVal {
			t.Errorf("mem doesn't match expected values at: %v", i)
		}
	}
}

func TestGoStrToCStr(t *testing.T) {
	goStr := "string\000"
	bStr := goStrToCStr(goStr)

	testData := []byte{'s', 't', 'r', 'i', 'n', 'g', '\000'}

	for i := 0; i < len(goStr); i++ {
		val := *indxBytePtr(unsafe.Pointer(bStr), i)
		testVal := testData[i]
		if val != testVal {
			t.Errorf("Wanted: %v, but got: %v", testVal, val)
		}
	}
}

func TestStrdup(t *testing.T) {
	goStr := "string\000"
	bStr := goStrToCStr(goStr)

	testData := []byte{'s', 't', 'r', 'i', 'n', 'g', '\000'}

	newStr := strdup(bStr)

	for i := 0; i < len(goStr); i++ {
		val := *indxBytePtr(unsafe.Pointer(newStr), i)
		testVal := testData[i]
		if val != testVal {
			t.Errorf("Wanted: %v, but got: %v", testVal, val)
		}
	}
}

func TestStrlen(t *testing.T) {
	goStr := "string\000"
	bStr := goStrToCStr(goStr)
	eLength := 6
	oLength := strlen(bStr)
	if oLength != int32(eLength) {
		t.Errorf("Wanted: %v, but got: %v", eLength, oLength)
	}
}

func TestStrchr(t *testing.T) {
	goStr := "string\000"
	bStr := goStrToCStr(goStr)
	// First try to find something that is in the string
	ePtr := uintptr(incBytePtr(unsafe.Pointer(bStr), 2))
	obtainedPtr := uintptr(unsafe.Pointer(strchr(bStr, 'r')))
	if ePtr != obtainedPtr {
		t.Errorf("wanted: %v, but got: %v", ePtr, obtainedPtr)
	}
	// Now try something that isn't actually in the string
	obtainedPtr2 := strchr(bStr, 'k')
	ePtr2 := (*byte)(nil)
	if ePtr2 != obtainedPtr2 {
		t.Errorf("wanted: %v, but got: %v", ePtr, obtainedPtr)
	}
}

func TestIncPtr(t *testing.T) {
	// Test how it deals with bytes
	bytePtr := unsafe.Pointer(&byteArr[arrStart])
	valueByte := *(*byte)(incPtr(bytePtr, inc, byteSize))
	if valueByte != byteArr[inc] {
		t.Errorf(errMsg, valueByte, byteArr[inc])
	}

	// Test how it deals with int32s
	int32Ptr := unsafe.Pointer(&int32Arr[arrStart])
	valueInt32 := *(*int32)(incPtr(int32Ptr, inc, int32Size))
	if valueInt32 != int32Arr[inc] {
		t.Errorf(errMsg, valueInt32, int32Arr[inc])
	}

	// Test how it deals with int64
	int64Ptr := unsafe.Pointer(&int64Arr[arrStart])
	valueInt64 := *(*int64)(incPtr(int64Ptr, inc, int64Size))
	if valueInt64 != int64Arr[inc] {
		t.Errorf(errMsg, valueInt64, int64Arr[inc])
	}
}

func TestDecPtr(t *testing.T) {
	// Test how it deals with bytes
	bytePtr := unsafe.Pointer(&byteArr[arrEnd])
	valueByte := *(*byte)(decPtr(bytePtr, dec, byteSize))
	if valueByte != byteArr[arrEnd-dec] {
		t.Errorf(errMsg, valueByte, byteArr[inc])
	}

	// Test how it deals with ints
	int32Ptr := unsafe.Pointer(&int32Arr[arrEnd])
	valueInt32 := *(*int32)(decPtr(int32Ptr, dec, int32Size))
	if valueInt32 != int32Arr[arrEnd-inc] {
		t.Errorf(errMsg, valueInt32, int32Arr[inc])
	}

	// Test how it deals with int64
	int64Ptr := unsafe.Pointer(&int64Arr[arrEnd])
	valueInt64 := *(*int64)(decPtr(int64Ptr, dec, int64Size))
	if valueInt64 != int64Arr[arrEnd-dec] {
		t.Errorf(errMsg, valueInt64, int64Arr[inc])
	}
}

func TestIndxBytePtr(t *testing.T) {
	// Test how it deals with bytes
	bytePtr := unsafe.Pointer(&byteArr[arrStart])
	valueByte := indxBytePtr(bytePtr, inc)
	if *valueByte != byteArr[inc] {
		t.Errorf(errMsg, valueByte, byteArr[inc])
	}
}

func TestIndxInt32Ptr(t *testing.T) {
	// Test how it deals with int32s
	int32Ptr := unsafe.Pointer(&int32Arr[arrStart])
	valueInt32 := indxInt32Ptr(int32Ptr, inc)
	if *valueInt32 != int32Arr[inc] {
		t.Errorf(errMsg, valueInt32, int32Arr[inc])
	}
}

func TestIndxInt64Ptr(t *testing.T) {
	// Test how it deals with int64
	int64Ptr := unsafe.Pointer(&int64Arr[arrStart])
	valueInt64 := indxInt64Ptr(int64Ptr, inc)
	if *valueInt64 != int64Arr[inc] {
		t.Errorf(errMsg, valueInt64, int64Arr[inc])
	}
}

/*
func TestPtrToSlice(t *testing.T){
}
*/