Add first implementations and tests of data functions

Author: olabini

.travis.yml

@@ -0,0 +1,15 @@
+dist: trusty
+sudo: required
+language: go
+
+go:
+  - tip
+  - "1.10.3"
+
+install: make deps
+script: make test
+
+matrix:
+  allow_failures:
+    - go: tip
+  fast_finish: true

Gopkg.lock

@@ -0,0 +1,34 @@
+# Gopkg.toml example
+#
+# Refer to https://github.com/golang/dep/blob/master/docs/Gopkg.toml.md
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+
+[[constraint]]
+  branch = "v1"
+  name = "gopkg.in/check.v1"
+
+[prune]
+  go-tests = true
+  unused-packages = true

Gopkg.toml

@@ -0,0 +1,42 @@
+package gotrax
+
+import "math/big"
+
+// AppendShort will append the serialization of the given value to the byte array
+// Data will be serialized big-endian
+func AppendShort(l []byte, r uint16) []byte {
+	return append(l, SerializeShort(r)...)
+}
+
+// AppendWord will append the serialization of the given value to the byte array
+// Data will be serialized big-endian
+func AppendWord(l []byte, r uint32) []byte {
+	return append(l, SerializeWord(r)...)
+}
+
+// AppendLong will append the serialization of the given value to the byte array
+// Data will be serialized big-endian
+func AppendLong(l []byte, r uint64) []byte {
+	return append(l, SerializeLong(r)...)
+}
+
+// AppendData will append the serialization of the given value to the byte array
+// Data will be serialized big-endian
+func AppendData(l, r []byte) []byte {
+	return append(AppendWord(l, uint32(len(r))), r...)
+}
+
+// AppendMPI will append the serialization of the given value to the byte array
+// Data will be serialized big-endian
+func AppendMPI(l []byte, r *big.Int) []byte {
+	return AppendData(l, r.Bytes())
+}
+
+// AppendMPIs will append the serialization of the given values to the byte array
+// Data will be serialized big-endian
+func AppendMPIs(l []byte, r ...*big.Int) []byte {
+	for _, mpi := range r {
+		l = AppendMPI(l, mpi)
+	}
+	return l
+}

append.go

@@ -0,0 +1,60 @@
+package gotrax
+
+import (
+	"math/big"
+	"testing"
+	"time"
+
+	. "gopkg.in/check.v1"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type GotraxSuite struct{}
+
+var _ = Suite(&GotraxSuite{})
+
+func (s *GotraxSuite) Test_AppendLong_serializesTimeCorrectly(c *C) {
+	tt := time.Date(2028, 11, 5, 13, 46, 00, 13, time.UTC)
+	num := tt.Unix()
+	c.Assert(num, Equals, int64(0x6EB04118))
+	c.Assert(AppendLong(nil, uint64(num)), DeepEquals, []byte{0x00, 0x00, 0x00, 0x00, 0x6e, 0xb0, 0x41, 0x18})
+
+	tt2 := time.Date(1968, 11, 5, 13, 46, 00, 13, time.UTC)
+	num2 := tt2.Unix()
+	c.Assert(num2, Equals, int64(-0x022B9768))
+	c.Assert(AppendLong(nil, uint64(num2)), DeepEquals, []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xD4, 0x68, 0x98})
+}
+
+func (s *GotraxSuite) Test_AppendShort_willAppendTheShort(c *C) {
+	before := []byte{0x12, 0x14}
+	result := AppendShort(before, 0x4215)
+	c.Assert(result, DeepEquals, []byte{0x12, 0x14, 0x42, 0x15})
+}
+
+func (s *GotraxSuite) Test_AppendWord_WillAppendTheWord(c *C) {
+	before := []byte{0x12, 0x14}
+	result := AppendWord(before, 0x334D1215)
+	c.Assert(result, DeepEquals, []byte{0x12, 0x14, 0x33, 0x4D, 0x12, 0x15})
+}
+
+func (s *GotraxSuite) Test_AppendData_WillAppendBytes(c *C) {
+	before := []byte{0x13, 0x54}
+	result := AppendData(before, []byte{0x55, 0x12, 0x04, 0x8A, 0x00})
+	c.Assert(result, DeepEquals, []byte{0x13, 0x54, 0x00, 0x00, 0x00, 0x05, 0x55, 0x12, 0x04, 0x8A, 0x00})
+}
+
+func (s *GotraxSuite) Test_AppendMPI_WillAppendTheMPI(c *C) {
+	before := []byte{0x13, 0x54}
+	result := AppendMPI(before, new(big.Int).SetBytes([]byte{0x55, 0x12, 0x04, 0x8A, 0x00}))
+	c.Assert(result, DeepEquals, []byte{0x13, 0x54, 0x00, 0x00, 0x00, 0x05, 0x55, 0x12, 0x04, 0x8A, 0x00})
+}
+
+func (s *GotraxSuite) Test_AppendMPIs_WillAppendTheMPIs(c *C) {
+	before := []byte{0x13, 0x54}
+	one := new(big.Int).SetBytes([]byte{0x55, 0x12, 0x04, 0x8A, 0x00})
+	two := new(big.Int).SetBytes([]byte{0x01, 0x53, 0xCC})
+	three := new(big.Int).SetBytes([]byte{0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01})
+	result := AppendMPIs(before, one, two, three)
+	c.Assert(result, DeepEquals, []byte{0x13, 0x54, 0x00, 0x00, 0x00, 0x05, 0x55, 0x12, 0x04, 0x8A, 0x00, 0x00, 0x00, 0x00, 0x03, 0x01, 0x53, 0xCC, 0x00, 0x00, 0x00, 0x0A, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01})
+}

append_test.go

@@ -0,0 +1,114 @@
+package gotrax
+
+import (
+	"math/big"
+	"time"
+)
+
+// ExtractByte will return the first byte, the rest, and a boolean indicating success
+// Data is expected to be in big-endian format
+func ExtractByte(d []byte) ([]byte, uint8, bool) {
+	if len(d) < 1 {
+		return nil, 0, false
+	}
+
+	return d[1:], uint8(d[0]), true
+}
+
+// ExtractShort will return the first short, the rest, and a boolean indicating success
+// Data is expected to be in big-endian format
+func ExtractShort(d []byte) ([]byte, uint16, bool) {
+	if len(d) < 2 {
+		return nil, 0, false
+	}
+
+	return d[2:], DeserializeShort(d), true
+}
+
+// ExtractWord will return the first word, the rest, and a boolean indicating success
+// Data is expected to be in big-endian format
+func ExtractWord(d []byte) ([]byte, uint32, bool) {
+	if len(d) < 4 {
+		return nil, 0, false
+	}
+
+	return d[4:], DeserializeWord(d), true
+}
+
+// ExtractLong will return the first long, the rest, and a boolean indicating success
+// Data is expected to be in big-endian format
+func ExtractLong(d []byte) ([]byte, uint64, bool) {
+	if len(d) < 8 {
+		return nil, 0, false
+	}
+
+	return d[8:], DeserializeLong(d), true
+}
+
+// ExtractData will return the first data, the rest, and a boolean indicating success
+// A Data is serialized as a word indicating length, and then as many bytes as that length
+// Data is expected to be in big-endian format
+func ExtractData(d []byte) (newPoint []byte, data []byte, ok bool) {
+	newPoint, length, ok := ExtractWord(d)
+	if !ok || len(newPoint) < int(length) {
+		return nil, nil, false
+	}
+
+	data = newPoint[:int(length)]
+	newPoint = newPoint[int(length):]
+	ok = true
+	return
+}
+
+// ExtractTime will return the first time, the rest, and a boolean indicating success
+// Time is encoded as a big-endian 64bit number
+func ExtractTime(d []byte) (newPoint []byte, t time.Time, ok bool) {
+	newPoint, tt, ok := ExtractLong(d)
+	if !ok {
+		return nil, time.Time{}, false
+	}
+	t = time.Unix(int64(tt), 0).In(time.UTC)
+	ok = true
+	return
+}
+
+// ExtractFixedData will return the first l bytes, the rest, and a boolean indicating success
+func ExtractFixedData(d []byte, l int) (newPoint []byte, data []byte, ok bool) {
+	if len(d) < l {
+		return nil, nil, false
+	}
+	return d[l:], d[0:l], true
+}
+
+// ExtractMPI will return the first MPI, the rest, and a boolean indicating success
+// The MPI is encoded as a word length, followed by length bytes indicating the minimal representation of the MPI in the obvious format.
+// Data is expected to be in big-endian format
+func ExtractMPI(d []byte) (newPoint []byte, mpi *big.Int, ok bool) {
+	d, mpiLen, ok := ExtractWord(d)
+	if !ok || len(d) < int(mpiLen) {
+		return nil, nil, false
+	}
+
+	mpi = new(big.Int).SetBytes(d[:int(mpiLen)])
+	newPoint = d[int(mpiLen):]
+	ok = true
+	return
+}
+
+// ExtractMPIs will return the first len MPIs, the rest, and a boolean indicating success
+// The length is indicated by a word, followed by length MPIs
+// Data is expected to be in big-endian format
+func ExtractMPIs(d []byte) ([]byte, []*big.Int, bool) {
+	current, mpiCount, ok := ExtractWord(d)
+	if !ok {
+		return nil, nil, false
+	}
+	result := make([]*big.Int, int(mpiCount))
+	for i := 0; i < int(mpiCount); i++ {
+		current, result[i], ok = ExtractMPI(current)
+		if !ok {
+			return nil, nil, false
+		}
+	}
+	return current, result, true
+}