2018-07-15 19:15:52 +03:00
|
|
|
/*
|
|
|
|
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 (
|
2018-07-20 14:58:00 +03:00
|
|
|
"testing"
|
|
|
|
"unsafe"
|
2018-07-15 19:15:52 +03:00
|
|
|
)
|
|
|
|
|
|
|
|
const (
|
2018-07-20 14:58:00 +03:00
|
|
|
arrStart = 0
|
|
|
|
arrEnd = 5
|
|
|
|
arrSize = 6
|
|
|
|
inc = 3
|
|
|
|
dec = 3
|
2018-07-15 19:15:52 +03:00
|
|
|
)
|
|
|
|
|
2018-08-12 14:15:46 +03:00
|
|
|
const (
|
|
|
|
byteSize = 1
|
|
|
|
int32Size = 4
|
|
|
|
int64Size = 8
|
|
|
|
)
|
|
|
|
|
2018-07-15 19:15:52 +03:00
|
|
|
var (
|
2018-07-20 14:58:00 +03:00
|
|
|
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"
|
2018-07-15 19:15:52 +03:00
|
|
|
)
|
|
|
|
|
2018-07-28 04:38:05 +03:00
|
|
|
// TODO: write test for realloc
|
|
|
|
// TODO: write test for memmove
|
|
|
|
// TODO: write test for allocate
|
|
|
|
|
2018-07-24 15:06:39 +03:00
|
|
|
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!")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-22 11:48:46 +03:00
|
|
|
func TestMemset(t *testing.T) {
|
|
|
|
size := 10
|
|
|
|
setNum := 5
|
|
|
|
testVal := byte('A')
|
2018-08-21 12:14:26 +03:00
|
|
|
mem := malloc(uintptr(size))
|
2018-08-12 14:15:46 +03:00
|
|
|
memset((*byte)(mem), int(testVal), setNum)
|
2018-07-22 11:48:46 +03:00
|
|
|
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)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-20 14:58:00 +03:00
|
|
|
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])
|
|
|
|
}
|
2018-07-15 19:15:52 +03:00
|
|
|
}
|
|
|
|
|
2018-07-20 14:58:00 +03:00
|
|
|
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])
|
|
|
|
}
|
2018-07-16 17:37:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestIndxBytePtr(t *testing.T) {
|
2018-07-20 14:58:00 +03:00
|
|
|
// 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])
|
|
|
|
}
|
2018-07-16 17:37:34 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
func TestIndxInt32Ptr(t *testing.T) {
|
2018-07-20 14:58:00 +03:00
|
|
|
// 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])
|
|
|
|
}
|
2018-07-15 19:15:52 +03:00
|
|
|
}
|
|
|
|
|
2018-07-16 17:37:34 +03:00
|
|
|
func TestIndxInt64Ptr(t *testing.T) {
|
2018-07-20 14:58:00 +03:00
|
|
|
// 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])
|
|
|
|
}
|
2018-07-16 17:37:34 +03:00
|
|
|
}
|
2018-07-15 19:15:52 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
func TestPtrToSlice(t *testing.T){
|
|
|
|
}
|
|
|
|
*/
|