binary_test.go

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// this file is the test cases from std.binary

package binary

import (
	"bytes"
	"io"
	"math"
	"reflect"
	"testing"
)

type Struct struct {
	Int8       int8
	Int16      int16
	Int32      int32
	Int64      int64
	Uint8      uint8
	Uint16     uint16
	Uint32     uint32
	Uint64     uint64
	Float32    float32
	Float64    float64
	Complex64  complex64
	Complex128 complex128
	Array      [4]uint8
	Bool       bool
	BoolArray  [4]bool
}

var _struct = Struct{
	0x01,               //Int8
	0x0203,             //Int16
	0x04050607,         //Int32
	0x08090a0b0c0d0e0f, //Int64
	0x10,               //Uint8
	0x1112,             //Uint16
	0x13141516,         //Uint32
	0x1718191a1b1c1d1e, //Uint64

	math.Float32frombits(0x1f202122),         //Float32
	math.Float64frombits(0x232425262728292a), //Float64
	complex(
		math.Float32frombits(0x2b2c2d2e),
		math.Float32frombits(0x2f303132),
	), //Complex64
	complex(
		math.Float64frombits(0x333435363738393a),
		math.Float64frombits(0x3b3c3d3e3f404142),
	), //Complex128

	[4]uint8{0x43, 0x44, 0x45, 0x46}, //Array

	true, //Bool
	[4]bool{true, false, true, false}, //BoolArray
}

var big = []byte{
	1,
	2, 3,
	4, 5, 6, 7,
	8, 9, 10, 11, 12, 13, 14, 15,
	16,
	17, 18,
	19, 20, 21, 22,
	23, 24, 25, 26, 27, 28, 29, 30,

	31, 32, 33, 34,
	35, 36, 37, 38, 39, 40, 41, 42,
	43, 44, 45, 46, 47, 48, 49, 50,
	51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66,

	4, 67, 68, 69, 70,

	1,
	4, 5,
}

var little = []byte{
	1,
	3, 2,
	7, 6, 5, 4,
	15, 14, 13, 12, 11, 10, 9, 8,
	16,
	18, 17,
	22, 21, 20, 19,
	30, 29, 28, 27, 26, 25, 24, 23,

	34, 33, 32, 31,
	42, 41, 40, 39, 38, 37, 36, 35,
	46, 45, 44, 43, 50, 49, 48, 47,
	58, 57, 56, 55, 54, 53, 52, 51, 66, 65, 64, 63, 62, 61, 60, 59,

	4, 67, 68, 69, 70,

	1,
	4, 5,
}

var src = []byte{2, 1, 2, 3, 4, 5, 6, 7, 8}
var res = []int32{0x01020304, 0x05060708}

func checkResult(t *testing.T, dir string, order Endian, err error, have, want interface{}) {
	if err != nil {
		t.Errorf("%v %v: %v", dir, order, err)
		return
	}
	if !reflect.DeepEqual(have, want) {
		t.Errorf("%v %v:\n\thave %+v\n\twant %+v", dir, order, have, want)
	}
}

func testRead(t *testing.T, order Endian, b []byte, s1 interface{}) {
	var s2 Struct
	err := Read(bytes.NewReader(b), order, &s2)
	checkResult(t, "Read", order, err, s2, s1)
}

func testWrite(t *testing.T, order Endian, b []byte, s1 interface{}) {
	buf := new(bytes.Buffer)
	err := Write(buf, order, s1)
	checkResult(t, "Write", order, err, buf.Bytes(), b)
}

func TestLittleEndianRead(t *testing.T)     { testRead(t, LittleEndian, little, _struct) }
func TestLittleEndianWrite(t *testing.T)    { testWrite(t, LittleEndian, little, _struct) }
func TestLittleEndianPtrWrite(t *testing.T) { testWrite(t, LittleEndian, little, &_struct) }

func TestBigEndianRead(t *testing.T)     { testRead(t, BigEndian, big, _struct) }
func TestBigEndianWrite(t *testing.T)    { testWrite(t, BigEndian, big, _struct) }
func TestBigEndianPtrWrite(t *testing.T) { testWrite(t, BigEndian, big, &_struct) }

func TestReadSlice(t *testing.T) {
	slice := make([]int32, 2)
	err := Read(bytes.NewReader(src), BigEndian, &slice)
	checkResult(t, "ReadSlice", BigEndian, err, slice, res)
}

func TestWriteSlice(t *testing.T) {
	buf := new(bytes.Buffer)
	err := Write(buf, BigEndian, res)
	checkResult(t, "WriteSlice", BigEndian, err, buf.Bytes(), src)
}

func TestReadBool(t *testing.T) {
	var (
		res bool
		err error
	)
	err = Read(bytes.NewReader([]byte{0}), BigEndian, &res)
	checkResult(t, "ReadBool", BigEndian, err, res, false)
	res = false
	err = Read(bytes.NewReader([]byte{1}), BigEndian, &res)
	checkResult(t, "ReadBool", BigEndian, err, res, true)
	res = false
	type boolSet struct {
		A bool
		B byte
		C bool
	}
	var boolSet1 boolSet
	var boolSet2 = boolSet{false, 15, true}
	err = Read(bytes.NewReader([]byte{2, 15}), BigEndian, &boolSet1)
	checkResult(t, "ReadBool", BigEndian, err, boolSet1, boolSet2)
}

func TestReadBoolSlice(t *testing.T) {
	slice := make([]bool, 4)
	err := Read(bytes.NewReader([]byte{4, 14}), BigEndian, &slice)
	checkResult(t, "ReadBoolSlice", BigEndian, err, slice, []bool{false, true, true, true})
}

// Addresses of arrays are easier to manipulate with reflection than are slices.
var intArrays = []interface{}{
	&[100]int8{},
	&[100]int16{},
	&[100]int32{},
	&[100]int64{},
	&[100]uint8{},
	&[100]uint16{},
	&[100]uint32{},
	&[100]uint64{},
}

func TestSliceRoundTrip(t *testing.T) {
	buf := new(bytes.Buffer)
	for _, array := range intArrays {
		src := reflect.ValueOf(array).Elem()
		unsigned := false
		switch src.Index(0).Kind() {
		case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
			unsigned = true
		}
		for i := 0; i < src.Len(); i++ {
			if unsigned {
				src.Index(i).SetUint(uint64(i * 0x07654321))
			} else {
				src.Index(i).SetInt(int64(i * 0x07654321))
			}
		}
		buf.Reset()
		srcSlice := src.Slice(0, src.Len())
		err := Write(buf, BigEndian, srcSlice.Interface())
		if err != nil {
			t.Fatal(err)
		}
		dst := reflect.New(src.Type())
		err = Read(buf, BigEndian, dst.Interface())
		if err != nil {
			t.Fatal(err)
		}
		if !reflect.DeepEqual(src.Interface(), dst.Elem().Interface()) {
			t.Fatal(src)
		}
	}
}

func TestDonotSupportedType(t *testing.T) {
	buf := new(bytes.Buffer)
	ts := doNotSupportTypes
	if err := Write(buf, BigEndian, ts); err == nil {
		t.Errorf("WriteDonotSupportedType: have err == nil, want non-nil")
	}

	tv := reflect.Indirect(reflect.ValueOf(&ts))
	for i, n := 0, tv.NumField(); i < n; i++ {
		//		if Sizeof(tv.Field(i).Interface()) >= 0 {
		//			panic(tv.Field(i))
		//		}
		if err := Write(buf, BigEndian, tv.Field(i).Interface()); err == nil {
			t.Errorf("Write DonotSupportedType.%v: have err == nil, want non-nil", tv.Field(i).Type())
		} else {
			//println(err.Error())
		}

		if err := Read(buf, BigEndian, tv.Field(i).Addr().Interface()); err == nil {
			t.Errorf("Read DonotSupportedType.%v: have err == nil, want non-nil", tv.Field(i).Type())
		} else {
			//println(err.Error())
		}
	}
}

type BlankFields struct {
	A uint32
	_ int32
	B float64
	_ [4]int16
	C byte
	_ [7]byte
	_ struct {
		f [8]float32
	}
}

type BlankFieldsProbe struct {
	A  uint32
	P0 int32 `binary:"ignore"`
	B  float64
	P1 [4]int16 `binary:"ignore"`
	C  byte
	P2 [7]byte `binary:"ignore"`
	P3 struct {
		F [8]float32
	} `binary:"ignore"`
}

func TestBlankFields(t *testing.T) {
	buf := new(bytes.Buffer)
	b1 := BlankFields{A: 1234567890, B: 2.718281828, C: 42}
	if err := Write(buf, LittleEndian, &b1); err != nil {
		t.Error(err)
	}

	// zero values must have been written for blank fields
	var p BlankFieldsProbe
	if err := Read(buf, LittleEndian, &p); err != nil {
		t.Error(err)
	}

	// quick test: only check first value of slices
	if p.P0 != 0 || p.P1[0] != 0 || p.P2[0] != 0 || p.P3.F[0] != 0 {
		t.Errorf("non-zero values for originally blank fields: %#v", p)
	}

	// write p and see if we can probe only some fields
	if err := Write(buf, LittleEndian, &p); err != nil {
		t.Error(err)
	}

	// read should ignore blank fields in b2
	var b2 BlankFields
	if err := Read(buf, LittleEndian, &b2); err != nil {
		t.Error(err)
	}
	if b1.A != b2.A || b1.B != b2.B || b1.C != b2.C {
		t.Errorf("%#v != %#v", b1, b2)
	}
}

//************************************************************************************
// Different form std.binary, unexported filed will be ignored when encoding/decoding.
// So TestUnexportedRead is not suitable for this package.
//************************************************************************************

//// An attempt to read into a struct with an unexported field will
//// panic. This is probably not the best choice, but at this point
//// anything else would be an API change.
//
//type Unexported struct {
//	a int32
//}
//
//func TestUnexportedRead(t *testing.T) {
//	var buf bytes.Buffer
//	u1 := Unexported{a: 1}
//	if err := Write(&buf, LittleEndian, &u1); err != nil {
//		t.Fatal(err)
//	}
//
//	defer func() {
//		if recover() == nil {
//			t.Fatal("did not panic")
//		}
//	}()
//	var u2 Unexported
//	Read(&buf, LittleEndian, &u2)
//}

func TestReadErrorMsg(t *testing.T) {
	var buf bytes.Buffer
	read := func(data interface{}, nonPointer bool) {
		err := Read(&buf, LittleEndian, data)
		want := "binary.Decoder.Value: unsupported type " + reflect.TypeOf(data).String()
		if nonPointer {
			want = "binary.Decoder.Value: non-pointer type " + reflect.TypeOf(data).String()
		}
		if err == nil {
			t.Errorf("%T: got no error; want %q", data, want)
			return
		}
		if got := err.Error(); got != want {
			t.Errorf("%T: got %q; want %q", data, got, want)
		}
	}
	i := uintptr(0)
	read(&i, false)
	s := new(struct{})
	read(*s, true)
	read(&s, false)
	p := &s
	read(&p, false)
}

func TestReadTruncated(t *testing.T) {
	var data = []byte{0x4, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf}

	var b1 = make([]int32, 4)
	var b2 struct {
		A0, A, B, C, D byte
		E              int32
		F              float64
	}

	for i := 0; i <= len(data); i++ {
		var errWant error
		switch i {
		case 0:
			errWant = io.ErrUnexpectedEOF
		case len(data):
			errWant = nil
		default:
			errWant = io.ErrUnexpectedEOF
		}

		if err := Read(bytes.NewReader(data[:i]), LittleEndian, &b1); err != errWant {
			t.Errorf("Read(%d) with slice: got %v, want %v", i, err, errWant)
		}
		if err := Read(bytes.NewReader(data[:i]), LittleEndian, &b2); err != errWant {
			t.Errorf("Read(%d) with struct: got %v, want %v", i, err, errWant)
		}
	}
}

func testUint64SmallSliceLengthPanics() (panicked bool) {
	defer func() {
		panicked = recover() != nil
	}()
	b := [8]byte{1, 2, 3, 4, 5, 6, 7, 8}
	LittleEndian.Uint64(b[:4])
	return false
}

func testPutUint64SmallSliceLengthPanics() (panicked bool) {
	defer func() {
		panicked = recover() != nil
	}()
	b := [8]byte{}
	LittleEndian.PutUint64(b[:4], 0x0102030405060708)
	return false
}

func TestEarlyBoundsChecks(t *testing.T) {
	if !testUint64SmallSliceLengthPanics() {
		t.Errorf("binary.LittleEndian.Uint64 expected to panic for small slices, but didn't")
	}
	if !testPutUint64SmallSliceLengthPanics() {
		t.Errorf("binary.LittleEndian.PutUint64 expected to panic for small slices, but didn't")
	}
}

type byteSliceReader struct {
	remain []byte
}

func (br *byteSliceReader) Read(p []byte) (int, error) {
	n := copy(p, br.remain)
	br.remain = br.remain[n:]
	return n, nil
}

//func BenchmarkReadSlice1000Int32s(b *testing.B) {
//	bsr := &byteSliceReader{}
//	slice := make([]int32, 1000)
//	buf := make([]byte, len(slice)*4)
//	b.SetBytes(int64(len(buf)))
//	b.ResetTimer()
//	for i := 0; i < b.N; i++ {
//		bsr.remain = buf
//		Read(bsr, BigEndian, slice)
//	}
//}

//func BenchmarkReadStruct(b *testing.B) {
//	bsr := &byteSliceReader{}
//	var buf bytes.Buffer
//	Write(&buf, BigEndian, &s)
//	b.SetBytes(int64(sizeofValue(reflect.ValueOf(s))))
//	t := s
//	b.ResetTimer()
//	for i := 0; i < b.N; i++ {
//		bsr.remain = buf.Bytes()
//		Read(bsr, BigEndian, &t)
//	}
//	b.StopTimer()
//	if b.N > 0 && !reflect.DeepEqual(s, t) {
//		b.Fatalf("struct doesn't match:\ngot  %v;\nwant %v", t, s)
//	}
//}

//func BenchmarkReadInts(b *testing.B) {
//	var ls Struct
//	bsr := &byteSliceReader{}
//	var r io.Reader = bsr
//	b.SetBytes(2 * (1 + 2 + 4 + 8))
//	b.ResetTimer()
//	for i := 0; i < b.N; i++ {
//		bsr.remain = big
//		Read(r, BigEndian, &ls.Int8)
//		Read(r, BigEndian, &ls.Int16)
//		Read(r, BigEndian, &ls.Int32)
//		Read(r, BigEndian, &ls.Int64)
//		Read(r, BigEndian, &ls.Uint8)
//		Read(r, BigEndian, &ls.Uint16)
//		Read(r, BigEndian, &ls.Uint32)
//		Read(r, BigEndian, &ls.Uint64)
//	}
//	b.StopTimer()
//	want := s
//	want.Float32 = 0
//	want.Float64 = 0
//	want.Complex64 = 0
//	want.Complex128 = 0
//	want.Array = [4]uint8{0, 0, 0, 0}
//	want.Bool = false
//	want.BoolArray = [4]bool{false, false, false, false}
//	if b.N > 0 && !reflect.DeepEqual(ls, want) {
//		b.Fatalf("struct doesn't match:\ngot  %v;\nwant %v", ls, want)
//	}
//}

//func BenchmarkWriteInts(b *testing.B) {
//	buf := new(bytes.Buffer)
//	var w io.Writer = buf
//	b.SetBytes(2 * (1 + 2 + 4 + 8))
//	b.ResetTimer()
//	for i := 0; i < b.N; i++ {
//		buf.Reset()
//		Write(w, BigEndian, s.Int8)
//		Write(w, BigEndian, s.Int16)
//		Write(w, BigEndian, s.Int32)
//		Write(w, BigEndian, s.Int64)
//		Write(w, BigEndian, s.Uint8)
//		Write(w, BigEndian, s.Uint16)
//		Write(w, BigEndian, s.Uint32)
//		Write(w, BigEndian, s.Uint64)
//	}
//	b.StopTimer()
//	if b.N > 0 && !bytes.Equal(buf.Bytes(), big[:30]) {
//		b.Fatalf("first half doesn't match: %x %x", buf.Bytes(), big[:30])
//	}
//}

//func BenchmarkWriteSlice1000Int32s(b *testing.B) {
//	slice := make([]int32, 1000)
//	buf := new(bytes.Buffer)
//	var w io.Writer = buf
//	b.SetBytes(4 * 1000)
//	b.ResetTimer()
//	for i := 0; i < b.N; i++ {
//		buf.Reset()
//		Write(w, BigEndian, slice)
//	}
//	b.StopTimer()
//}