route/vendor/github.com/bifurcation/mint/syntax/decode_test.go

220 lines
5.4 KiB
Go
Raw Normal View History

2018-01-03 19:19:49 +00:00
package syntax
import (
"reflect"
"testing"
)
func TestDecodeUnsupported(t *testing.T) {
var y struct {
Strings []string
}
read, err := Unmarshal(z8, &y)
if err == nil || read != 0 {
t.Fatalf("Agreed to unmarshal an unsupported type")
}
var yi int
read, err = Unmarshal(z8, yi)
if err == nil || read != 0 {
t.Fatalf("Agreed to unmarshal to a non-pointer")
}
read, err = Unmarshal(z8, nil)
if err == nil || read != 0 {
t.Fatalf("Agreed to unmarshal to a nil pointer")
}
}
func TestDecodeBasicTypes(t *testing.T) {
var y8 uint8
read, err := Unmarshal(z8, &y8)
if err != nil || y8 != x8 || read != 1 {
t.Fatalf("uint8 decode failed [%v] [%x]", err, y8)
}
var y16 uint16
read, err = Unmarshal(z16, &y16)
if err != nil || y16 != x16 || read != 2 {
t.Fatalf("uint16 decode failed [%v] [%x]", err, y16)
}
var y32 uint32
read, err = Unmarshal(z32, &y32)
if err != nil || y32 != x32 || read != 4 {
t.Fatalf("uint32 decode failed [%v] [%x]", err, y32)
}
var y64 uint64
read, err = Unmarshal(z64, &y64)
if err != nil || y64 != x64 || read != 8 {
t.Fatalf("uint64 decode failed [%v] [%x]", err, y64)
}
read, err = Unmarshal(z8[:0], &y8)
if err == nil || read != 0 {
t.Fatalf("Allowed uint8 decode from an empty buffer")
}
read, err = Unmarshal(z64[:2], &y64)
if err == nil || read != 0 {
t.Fatalf("Allowed uint64 decode from an incomplete buffer")
}
}
func TestDecodeVarint(t *testing.T) {
var yvi struct {
U8 uint8 `tls:"varint"`
U16 uint16 `tls:"varint"`
U32 uint32 `tls:"varint"`
U64 uint64 `tls:"varint"`
}
read, err := Unmarshal(zvi, &yvi)
if err != nil || !reflect.DeepEqual(yvi, xvi) || read != len(zvi) {
t.Fatalf("varint decode failed [%v] [%v]", err, yvi)
}
}
func TestDecodeArray(t *testing.T) {
var ya [5]uint16
read, err := Unmarshal(za, &ya)
if err != nil || !reflect.DeepEqual(ya, xa) || read != 10 {
t.Fatalf("[5]uint16 decode failed [%v] [%x]", err, ya)
}
}
func TestDecodeSlice(t *testing.T) {
var yv20 struct {
V []byte `tls:"head=1"`
}
read, err := Unmarshal(zv20, &yv20)
if err != nil || !reflect.DeepEqual(yv20, xv20) || read != len(zv20) {
t.Fatalf("[0x20]uint8 decode failed [%v] [%x]", err, yv20.V)
}
var yv200 struct {
V []byte `tls:"head=2"`
}
read, err = Unmarshal(zv200, &yv200)
if err != nil || !reflect.DeepEqual(yv200, xv200) || read != len(zv200) {
t.Fatalf("[0x200]uint8 decode failed [%v] [%x]", err, yv200.V)
}
var yv20000 struct {
V []byte `tls:"head=3"`
}
read, err = Unmarshal(zv20000, &yv20000)
if err != nil || !reflect.DeepEqual(yv20000, xv20000) || read != len(zv20000) {
t.Fatalf("[0x20000]uint8 decode failed [%v] [%x]", err, yv20000.V)
}
var yvEhead struct {
V []byte
}
read, err = Unmarshal(zv20, &yvEhead)
if err == nil || read != 0 {
t.Fatalf("Allowed a vector decode with no head")
}
var yvEmax struct {
V []byte `tls:"head=1,max=31"`
}
read, err = Unmarshal(zv20, &yvEmax)
if err == nil || read != 0 {
t.Fatalf("Allowed a vector decode with length exceeding max")
}
var yvEmin struct {
V []byte `tls:"head=1,min=33"`
}
read, err = Unmarshal(zv20, &yvEmin)
if err == nil || read != 0 {
t.Fatalf("Allowed a vector decode with length below min")
}
read, err = Unmarshal(zv200[:0], &yv200)
if err == nil || read != 0 {
t.Fatalf("Allowed a vector decode from an empty buffer")
}
read, err = Unmarshal(zv200[:1], &yv200)
if err == nil || read != 0 {
t.Fatalf("Allowed a vector decode with length too short")
}
read, err = Unmarshal(zv200[:2], &yv200)
if err == nil || read != 0 {
t.Fatalf("Allowed a vector decode shorter than declared length [%x]", yv200.V)
}
read, err = Unmarshal(zv200[:5], &yv200)
if err == nil || read != 0 {
t.Fatalf("Allowed a vector decode shorter than declared length [%x]", yv200.V)
}
}
func TestDecodeStruct(t *testing.T) {
var ys1 struct {
A uint16
B []uint8 `tls:"head=2"`
C [4]uint32
}
read, err := Unmarshal(zs1, &ys1)
if err != nil || !reflect.DeepEqual(ys1, xs1) || read != len(zs1) {
t.Fatalf("struct decode failed [%v] [%v]", err, ys1)
}
}
func TestDecodeUnmarshaler(t *testing.T) {
crypticStringUnmarshalCalls = 0
var ym CrypticString
read, err := Unmarshal(zm, &ym)
if err != nil || !reflect.DeepEqual(ym, xm) || read != len(zm) {
t.Fatalf("Unmarshaler decode failed [%v] [%v]", err, ym)
}
if crypticStringUnmarshalCalls != 1 {
t.Fatalf("CrypticString.UnmarshalTLS() was not called exactly once [%v]", crypticStringUnmarshalCalls)
}
crypticStringUnmarshalCalls = 0
var ysm struct {
A CrypticString
B uint16
C CrypticString
}
read, err = Unmarshal(zsm, &ysm)
if err != nil || !reflect.DeepEqual(ysm, xsm) || read != len(zsm) {
t.Fatalf("Struct-embedded unmarshaler decode failed [%v] [%v]", err, ysm)
}
if crypticStringUnmarshalCalls != 2 {
t.Fatalf("CrypticString.UnmarshalTLS() was not called exactly twice [%v]", crypticStringUnmarshalCalls)
}
}
func TestDecodeStructWithPointer(t *testing.T) {
var ysp struct {
A uint16
B *CrypticString
}
read, err := Unmarshal(zsp, &ysp)
if err != nil || !reflect.DeepEqual(ysp, xsp) || read != len(zsp) {
t.Fatalf("struct decode failed [%v] [%v]", err, ysp)
}
}
func TestIgnoreExtraData(t *testing.T) {
zsExtra := append(zs1, 0)
var ys1 struct {
A uint16
B []uint8 `tls:"head=2"`
C [4]uint32
}
read, err := Unmarshal(zsExtra, &ys1)
if err != nil || !reflect.DeepEqual(ys1, xs1) || read != len(zs1) {
t.Fatalf("struct decode failed [%v] [%v]", err, ys1)
}
}