add marshal test suite

internal/tests/utils/equal.go

@@ -0,0 +1,74 @@
+package utils
+
+import (
+	"bytes"
+	"fmt"
+	"gopkg.in/inf.v0"
+	"math/big"
+	"reflect"
+	"unsafe"
+
+	"github.com/gocql/gocql/marshal/tests/mod"
+)
+
+func EqualData(in1, in2 []byte) bool {
+	if in1 == nil || in2 == nil {
+		return in1 == nil && in2 == nil
+	}
+	return bytes.Equal(in1, in2)
+}
+
+func EqualVals(in1, in2 interface{}) bool {
+	rin1 := reflect.ValueOf(in1)
+	rin2 := reflect.ValueOf(in2)
+	if rin1.Kind() != rin2.Kind() {
+		return false
+	}
+	if rin1.Kind() == reflect.Ptr && (rin1.IsNil() || rin2.IsNil()) {
+		return rin1.IsNil() && rin2.IsNil()
+	}
+
+	switch vin1 := in1.(type) {
+	case float32:
+		vin2 := in2.(float32)
+		return *(*[4]byte)(unsafe.Pointer(&vin1)) == *(*[4]byte)(unsafe.Pointer(&vin2))
+	case *float32:
+		vin2 := in2.(*float32)
+		return *(*[4]byte)(unsafe.Pointer(vin1)) == *(*[4]byte)(unsafe.Pointer(vin2))
+	case *mod.Float32:
+		vin2 := in2.(*mod.Float32)
+		return *(*[4]byte)(unsafe.Pointer(vin1)) == *(*[4]byte)(unsafe.Pointer(vin2))
+	case mod.Float32:
+		vin2 := in2.(mod.Float32)
+		return *(*[4]byte)(unsafe.Pointer(&vin1)) == *(*[4]byte)(unsafe.Pointer(&vin2))
+	case float64:
+		vin2 := in2.(float64)
+		return *(*[8]byte)(unsafe.Pointer(&vin1)) == *(*[8]byte)(unsafe.Pointer(&vin2))
+	case *float64:
+		vin2 := in2.(*float64)
+		return *(*[8]byte)(unsafe.Pointer(vin1)) == *(*[8]byte)(unsafe.Pointer(vin2))
+	case *mod.Float64:
+		vin2 := in2.(*mod.Float64)
+		return *(*[8]byte)(unsafe.Pointer(vin1)) == *(*[8]byte)(unsafe.Pointer(vin2))
+	case mod.Float64:
+		vin2 := in2.(mod.Float64)
+		return *(*[8]byte)(unsafe.Pointer(&vin1)) == *(*[8]byte)(unsafe.Pointer(&vin2))
+	case big.Int:
+		vin2 := in2.(big.Int)
+		return vin1.Cmp(&vin2) == 0
+	case *big.Int:
+		vin2 := in2.(*big.Int)
+		return vin1.Cmp(vin2) == 0
+	case inf.Dec:
+		vin2 := in2.(inf.Dec)
+		return vin1.Cmp(&vin2) == 0
+	case *inf.Dec:
+		vin2 := in2.(*inf.Dec)
+		return vin1.Cmp(vin2) == 0
+	case fmt.Stringer:
+		vin2 := in2.(fmt.Stringer)
+		return vin1.String() == vin2.String()
+	default:
+		return reflect.DeepEqual(in1, in2)
+	}
+}

internal/tests/utils/new.go

@@ -0,0 +1,18 @@
+package utils
+
+import (
+	"reflect"
+)
+
+func NewRef(in interface{}) interface{} {
+	out := reflect.New(reflect.TypeOf(in)).Interface()
+	return out
+}
+
+func NewRefToZero(in interface{}) interface{} {
+	rv := reflect.ValueOf(in)
+	nw := reflect.New(rv.Type().Elem())
+	out := reflect.New(rv.Type())
+	out.Elem().Set(nw)
+	return out.Interface()
+}

internal/tests/utils/panic_err.go

@@ -0,0 +1,14 @@
+package utils
+
+import (
+	"fmt"
+)
+
+type PanicErr struct {
+	Err   error
+	Stack []byte
+}
+
+func (e PanicErr) Error() string {
+	return fmt.Sprintf("%v\n%s", e.Err, e.Stack)
+}

internal/tests/utils/string.go

@@ -0,0 +1,14 @@
+package utils
+
+import (
+	"fmt"
+)
+
+const printLimit = 100
+
+func StringData(p []byte) string {
+	if len(p) > printLimit {
+		p = p[:printLimit]
+	}
+	return fmt.Sprintf("[%x]", p)
+}

internal/tests/utils/string_vals.go

@@ -0,0 +1,52 @@
+package utils
+
+import (
+	"fmt"
+	"gopkg.in/inf.v0"
+	"math/big"
+	"net"
+	"reflect"
+	"time"
+)
+
+// StringValue returns (value_type)(value) in the human-readable format.
+func StringValue(in interface{}) string {
+	valStr := stringValue(in)
+	if len(valStr) > printLimit {
+		valStr = valStr[:printLimit]
+	}
+	return fmt.Sprintf("(%T)(%s)", in, valStr)
+}
+
+func stringValue(in interface{}) string {
+	switch i := in.(type) {
+	case string:
+		return i
+	case inf.Dec:
+		return fmt.Sprintf("%v", i.String())
+	case big.Int:
+		return fmt.Sprintf("%v", i.String())
+	case net.IP:
+		return fmt.Sprintf("%v", []byte(i))
+	case time.Time:
+		return fmt.Sprintf("%v", i.UnixMilli())
+	case nil:
+		return "nil"
+	}
+
+	rv := reflect.ValueOf(in)
+	switch rv.Kind() {
+	case reflect.Ptr:
+		if rv.IsNil() {
+			return "*nil"
+		}
+		return fmt.Sprintf("*%s", stringValue(rv.Elem().Interface()))
+	case reflect.Slice:
+		if rv.IsNil() {
+			return "[nil]"
+		}
+		return fmt.Sprintf("%v", rv.Interface())
+	default:
+		return fmt.Sprintf("%v", in)
+	}
+}

internal/tests/utils/utils.go

@@ -0,0 +1,23 @@
+package utils
+
+import (
+	"reflect"
+)
+
+func DeReference(in interface{}) interface{} {
+	return reflect.Indirect(reflect.ValueOf(in)).Interface()
+}
+
+func Reference(val interface{}) interface{} {
+	out := reflect.New(reflect.TypeOf(val))
+	out.Elem().Set(reflect.ValueOf(val))
+	return out.Interface()
+}
+
+func GetTypes(values ...interface{}) []reflect.Type {
+	types := make([]reflect.Type, len(values))
+	for i, value := range values {
+		types[i] = reflect.TypeOf(value)
+	}
+	return types
+}

marshal/tests/mod/all.go

@@ -0,0 +1,16 @@
+package mod
+
+var All = []Mod{CustomType, Reference, CustomTypeRef}
+
+// Mod - value modifiers.
+type Mod func(vals ...interface{}) []interface{}
+
+type Values []interface{}
+
+func (v Values) AddVariants(mods ...Mod) Values {
+	out := append(make([]interface{}, 0), v...)
+	for _, mod := range mods {
+		out = append(out, mod(v...)...)
+	}
+	return out
+}