1020 lines · 24.0 KB · Go
RawDownload
// 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. package gob import (	"bytes"	"encoding/hex"	"fmt"	"reflect"	"strings"	"testing") // Test basic operations in a safe manner.func TestBasicEncoderDecoder(t *testing.T) {	var values = []interface{}{		true,		int(123),		int8(123),		int16(-12345),		int32(123456),		int64(-1234567),		uint(123),		uint8(123),		uint16(12345),		uint32(123456),		uint64(1234567),		uintptr(12345678),		float32(1.2345),		float64(1.2345678),		complex64(1.2345 + 2.3456i),		complex128(1.2345678 + 2.3456789i),		[]byte("hello"),		string("hello"),	}	for _, value := range values {		b := new(bytes.Buffer)		enc := NewEncoder(b)		err := enc.Encode(value)		if err != nil {			t.Error("encoder fail:", err)		}		dec := NewDecoder(b)		result := reflect.New(reflect.TypeOf(value))		err = dec.Decode(result.Interface())		if err != nil {			t.Fatalf("error decoding %T: %v:", reflect.TypeOf(value), err)		}		if !reflect.DeepEqual(value, result.Elem().Interface()) {			t.Fatalf("%T: expected %v got %v", value, value, result.Elem().Interface())		}	}} type ET0 struct {	A int	B string} type ET2 struct {	X string} type ET1 struct {	A    int	Et2  *ET2	Next *ET1} // Like ET1 but with a different name for a fieldtype ET3 struct {	A             int	Et2           *ET2	DifferentNext *ET1} // Like ET1 but with a different type for a fieldtype ET4 struct {	A    int	Et2  float64	Next int} func TestEncoderDecoder(t *testing.T) {	b := new(bytes.Buffer)	enc := NewEncoder(b)	et0 := new(ET0)	et0.A = 7	et0.B = "gobs of fun"	err := enc.Encode(et0)	if err != nil {		t.Error("encoder fail:", err)	}	//fmt.Printf("% x %q\n", b, b)	//Debug(b)	dec := NewDecoder(b)	newEt0 := new(ET0)	err = dec.Decode(newEt0)	if err != nil {		t.Fatal("error decoding ET0:", err)	} 	if !reflect.DeepEqual(et0, newEt0) {		t.Fatalf("invalid data for et0: expected %+v; got %+v", *et0, *newEt0)	}	if b.Len() != 0 {		t.Error("not at eof;", b.Len(), "bytes left")	}	//	t.FailNow() 	b = new(bytes.Buffer)	enc = NewEncoder(b)	et1 := new(ET1)	et1.A = 7	et1.Et2 = new(ET2)	err = enc.Encode(et1)	if err != nil {		t.Error("encoder fail:", err)	}	dec = NewDecoder(b)	newEt1 := new(ET1)	err = dec.Decode(newEt1)	if err != nil {		t.Fatal("error decoding ET1:", err)	} 	if !reflect.DeepEqual(et1, newEt1) {		t.Fatalf("invalid data for et1: expected %+v; got %+v", *et1, *newEt1)	}	if b.Len() != 0 {		t.Error("not at eof;", b.Len(), "bytes left")	} 	enc.Encode(et1)	newEt1 = new(ET1)	err = dec.Decode(newEt1)	if err != nil {		t.Fatal("round 2: error decoding ET1:", err)	}	if !reflect.DeepEqual(et1, newEt1) {		t.Fatalf("round 2: invalid data for et1: expected %+v; got %+v", *et1, *newEt1)	}	if b.Len() != 0 {		t.Error("round 2: not at eof;", b.Len(), "bytes left")	} 	// Now test with a running encoder/decoder pair that we recognize a type mismatch.	err = enc.Encode(et1)	if err != nil {		t.Error("round 3: encoder fail:", err)	}	newEt2 := new(ET2)	err = dec.Decode(newEt2)	if err == nil {		t.Fatal("round 3: expected `bad type' error decoding ET2")	}} // Run one value through the encoder/decoder, but use the wrong type.// Input is always an ET1; we compare it to whatever is under 'e'.func badTypeCheck(e interface{}, shouldFail bool, msg string, t *testing.T) {	b := new(bytes.Buffer)	enc := NewEncoder(b)	et1 := new(ET1)	et1.A = 7	et1.Et2 = new(ET2)	err := enc.Encode(et1)	if err != nil {		t.Error("encoder fail:", err)	}	dec := NewDecoder(b)	err = dec.Decode(e)	if shouldFail && err == nil {		t.Error("expected error for", msg)	}	if !shouldFail && err != nil {		t.Error("unexpected error for", msg, err)	}} // Test that we recognize a bad type the first time.func TestWrongTypeDecoder(t *testing.T) {	badTypeCheck(new(ET2), true, "no fields in common", t)	badTypeCheck(new(ET3), false, "different name of field", t)	badTypeCheck(new(ET4), true, "different type of field", t)} // Types not supported at top level by the Encoder.var unsupportedValues = []interface{}{	make(chan int),	func(a int) bool { return true },} func TestUnsupported(t *testing.T) {	var b bytes.Buffer	enc := NewEncoder(&b)	for _, v := range unsupportedValues {		err := enc.Encode(v)		if err == nil {			t.Errorf("expected error for %T; got none", v)		}	}} func encAndDec(in, out interface{}) error {	b := new(bytes.Buffer)	enc := NewEncoder(b)	err := enc.Encode(in)	if err != nil {		return err	}	dec := NewDecoder(b)	err = dec.Decode(out)	if err != nil {		return err	}	return nil} func TestTypeToPtrType(t *testing.T) {	// Encode a T, decode a *T	type Type0 struct {		A int	}	t0 := Type0{7}	t0p := new(Type0)	if err := encAndDec(t0, t0p); err != nil {		t.Error(err)	}} func TestPtrTypeToType(t *testing.T) {	// Encode a *T, decode a T	type Type1 struct {		A uint	}	t1p := &Type1{17}	var t1 Type1	if err := encAndDec(t1, t1p); err != nil {		t.Error(err)	}} func TestTypeToPtrPtrPtrPtrType(t *testing.T) {	type Type2 struct {		A ****float64	}	t2 := Type2{}	t2.A = new(***float64)	*t2.A = new(**float64)	**t2.A = new(*float64)	***t2.A = new(float64)	****t2.A = 27.4	t2pppp := new(***Type2)	if err := encAndDec(t2, t2pppp); err != nil {		t.Fatal(err)	}	if ****(****t2pppp).A != ****t2.A {		t.Errorf("wrong value after decode: %g not %g", ****(****t2pppp).A, ****t2.A)	}} func TestSlice(t *testing.T) {	type Type3 struct {		A []string	}	t3p := &Type3{[]string{"hello", "world"}}	var t3 Type3	if err := encAndDec(t3, t3p); err != nil {		t.Error(err)	}} func TestValueError(t *testing.T) {	// Encode a *T, decode a T	type Type4 struct {		A int	}	t4p := &Type4{3}	var t4 Type4 // note: not a pointer.	if err := encAndDec(t4p, t4); err == nil || strings.Index(err.Error(), "pointer") < 0 {		t.Error("expected error about pointer; got", err)	}} func TestArray(t *testing.T) {	type Type5 struct {		A [3]string		B [3]byte	}	type Type6 struct {		A [2]string // can't hold t5.a	}	t5 := Type5{[3]string{"hello", ",", "world"}, [3]byte{1, 2, 3}}	var t5p Type5	if err := encAndDec(t5, &t5p); err != nil {		t.Error(err)	}	var t6 Type6	if err := encAndDec(t5, &t6); err == nil {		t.Error("should fail with mismatched array sizes")	}} func TestRecursiveMapType(t *testing.T) {	type recursiveMap map[string]recursiveMap	r1 := recursiveMap{"A": recursiveMap{"B": nil, "C": nil}, "D": nil}	r2 := make(recursiveMap)	if err := encAndDec(r1, &r2); err != nil {		t.Error(err)	}} func TestRecursiveSliceType(t *testing.T) {	type recursiveSlice []recursiveSlice	r1 := recursiveSlice{0: recursiveSlice{0: nil}, 1: nil}	r2 := make(recursiveSlice, 0)	if err := encAndDec(r1, &r2); err != nil {		t.Error(err)	}} // Regression test for bug: must send zero values inside arraysfunc TestDefaultsInArray(t *testing.T) {	type Type7 struct {		B []bool		I []int		S []string		F []float64	}	t7 := Type7{		[]bool{false, false, true},		[]int{0, 0, 1},		[]string{"hi", "", "there"},		[]float64{0, 0, 1},	}	var t7p Type7	if err := encAndDec(t7, &t7p); err != nil {		t.Error(err)	}} var testInt intvar testFloat32 float32var testString stringvar testSlice []stringvar testMap map[string]intvar testArray [7]int type SingleTest struct {	in  interface{}	out interface{}	err string} var singleTests = []SingleTest{	{17, &testInt, ""},	{float32(17.5), &testFloat32, ""},	{"bike shed", &testString, ""},	{[]string{"bike", "shed", "paint", "color"}, &testSlice, ""},	{map[string]int{"seven": 7, "twelve": 12}, &testMap, ""},	{[7]int{4, 55, 0, 0, 0, 0, 0}, &testArray, ""}, // case that once triggered a bug	{[7]int{4, 55, 1, 44, 22, 66, 1234}, &testArray, ""}, 	// Decode errors	{172, &testFloat32, "type"},} func TestSingletons(t *testing.T) {	b := new(bytes.Buffer)	enc := NewEncoder(b)	dec := NewDecoder(b)	for _, test := range singleTests {		b.Reset()		err := enc.Encode(test.in)		if err != nil {			t.Errorf("error encoding %v: %s", test.in, err)			continue		}		err = dec.Decode(test.out)		switch {		case err != nil && test.err == "":			t.Errorf("error decoding %v: %s", test.in, err)			continue		case err == nil && test.err != "":			t.Errorf("expected error decoding %v: %s", test.in, test.err)			continue		case err != nil && test.err != "":			if strings.Index(err.Error(), test.err) < 0 {				t.Errorf("wrong error decoding %v: wanted %s, got %v", test.in, test.err, err)			}			continue		}		// Get rid of the pointer in the rhs		val := reflect.ValueOf(test.out).Elem().Interface()		if !reflect.DeepEqual(test.in, val) {			t.Errorf("decoding singleton: expected %v got %v", test.in, val)		}	}} func TestStructNonStruct(t *testing.T) {	type Struct struct {		A string	}	type NonStruct string	s := Struct{"hello"}	var sp Struct	if err := encAndDec(s, &sp); err != nil {		t.Error(err)	}	var ns NonStruct	if err := encAndDec(s, &ns); err == nil {		t.Error("should get error for struct/non-struct")	} else if strings.Index(err.Error(), "type") < 0 {		t.Error("for struct/non-struct expected type error; got", err)	}	// Now try the other way	var nsp NonStruct	if err := encAndDec(ns, &nsp); err != nil {		t.Error(err)	}	if err := encAndDec(ns, &s); err == nil {		t.Error("should get error for non-struct/struct")	} else if strings.Index(err.Error(), "type") < 0 {		t.Error("for non-struct/struct expected type error; got", err)	}} type interfaceIndirectTestI interface {	F() bool} type interfaceIndirectTestT struct{} func (this *interfaceIndirectTestT) F() bool {	return true} // A version of a bug reported on golang-nuts.  Also tests top-level// slice of interfaces.  The issue was registering *T caused T to be// stored as the concrete type.func TestInterfaceIndirect(t *testing.T) {	Register(&interfaceIndirectTestT{})	b := new(bytes.Buffer)	w := []interfaceIndirectTestI{&interfaceIndirectTestT{}}	err := NewEncoder(b).Encode(w)	if err != nil {		t.Fatal("encode error:", err)	} 	var r []interfaceIndirectTestI	err = NewDecoder(b).Decode(&r)	if err != nil {		t.Fatal("decode error:", err)	}} // Now follow various tests that decode into things that can't represent the// encoded value, all of which should be legal. // Also, when the ignored object contains an interface value, it may define// types. Make sure that skipping the value still defines the types by using// the encoder/decoder pair to send a value afterwards.  If an interface// is sent, its type in the test is always NewType0, so this checks that the// encoder and decoder don't skew with respect to type definitions. type Struct0 struct {	I interface{}} type NewType0 struct {	S string} type ignoreTest struct {	in, out interface{}} var ignoreTests = []ignoreTest{	// Decode normal struct into an empty struct	{&struct{ A int }{23}, &struct{}{}},	// Decode normal struct into a nil.	{&struct{ A int }{23}, nil},	// Decode singleton string into a nil.	{"hello, world", nil},	// Decode singleton slice into a nil.	{[]int{1, 2, 3, 4}, nil},	// Decode struct containing an interface into a nil.	{&Struct0{&NewType0{"value0"}}, nil},	// Decode singleton slice of interfaces into a nil.	{[]interface{}{"hi", &NewType0{"value1"}, 23}, nil},} func TestDecodeIntoNothing(t *testing.T) {	Register(new(NewType0))	for i, test := range ignoreTests {		b := new(bytes.Buffer)

Lines 1–500 of 1020.

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t