From 41746a88444c6f6e3132bdf767ce29d06ce90daf Mon Sep 17 00:00:00 2001
From: saxon <saxon.milton@gmail.com>
Date: Tue, 17 Jul 2018 00:07:34 +0930
Subject: [PATCH] About to push

---
 rtmp/rtmp_test.go | 80 +++++++++++++++++++++++++++++++++++------------
 1 file changed, 60 insertions(+), 20 deletions(-)

diff --git a/rtmp/rtmp_test.go b/rtmp/rtmp_test.go
index 843a5c15..519ae269 100644
--- a/rtmp/rtmp_test.go
+++ b/rtmp/rtmp_test.go
@@ -33,39 +33,37 @@ import (
 )
 
 const (
-  byteSize  = 1
-  int32Size = 4
-  int64Size = 8
+  arrStart  = 0
+  arrEnd    = 5
+  arrSize   = 6
+  inc       = 3
+  dec       = 3
 )
 
 var (
-  byteArr   = [...]byte{0x01,0x02,0x03,0x04,0x05,0x06}
-  int32Arr  = [...]int32{1,2,3,4,5,6}
-  int64Arr  = [...]int64{1,2,3,4,5,6}
+  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"
 )
 
 func TestIncPtr(t *testing.T){
-  errMsg := "Obtained: %v, but wanted: %v"
-
   // Test how it deals with bytes
-  bytePtr := unsafe.Pointer(&byteArr[0])
-  inc := 4
+  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 ints
-  intPtr := unsafe.Pointer(&int32Arr[0])
-  inc = 3
-  valueInt32 := *(*int32)(incPtr(intPtr,inc,int32Size))
+  // 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[0])
-  inc = 5
+  int64Ptr := unsafe.Pointer(&int64Arr[arrStart])
   valueInt64 := *(*int64)(incPtr(int64Ptr,inc,int64Size))
   if valueInt64 != int64Arr[inc] {
     t.Errorf(errMsg,valueInt64,int64Arr[inc])
@@ -73,14 +71,56 @@ func TestIncPtr(t *testing.T){
 }
 
 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){
 }
 */
-
-func TestIndxPtr(t *testing.T){
-
-}