Imported Upstream version 60

1 files changed, 0 insertions, 551 deletions

diff --git a/src/pkg/gob/encoder_test.go b/src/pkg/gob/encoder_test.go
deleted file mode 100644
index 792afbd77..000000000
--- a/src/pkg/gob/encoder_test.go
+++ /dev/null
@@ -1,551 +0,0 @@
-// 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"
-	"fmt"
-	"io"
-	"os"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-type ET2 struct {
-	X string
-}
-
-type ET1 struct {
-	A    int
-	Et2  *ET2
-	Next *ET1
-}
-
-// Like ET1 but with a different name for a field
-type ET3 struct {
-	A             int
-	Et2           *ET2
-	DifferentNext *ET1
-}
-
-// Like ET1 but with a different type for a field
-type ET4 struct {
-	A    int
-	Et2  float64
-	Next int
-}
-
-func TestEncoderDecoder(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)
-	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)
-}
-
-func corruptDataCheck(s string, err os.Error, t *testing.T) {
-	b := bytes.NewBufferString(s)
-	dec := NewDecoder(b)
-	err1 := dec.Decode(new(ET2))
-	if err1 != err {
-		t.Errorf("from %q expected error %s; got %s", s, err, err1)
-	}
-}
-
-// Check that we survive bad data.
-func TestBadData(t *testing.T) {
-	corruptDataCheck("", os.EOF, t)
-	corruptDataCheck("\x7Fhi", io.ErrUnexpectedEOF, t)
-	corruptDataCheck("\x03now is the time for all good men", errBadType, t)
-}
-
-// Types not supported 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{}) os.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.String(), "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 arrays
-func 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 int
-var testFloat32 float32
-var testString string
-var testSlice []string
-var testMap map[string]int
-var 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, "wrong 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.String(), 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.String(), "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.String(), "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)
-		enc := NewEncoder(b)
-		err := enc.Encode(test.in)
-		if err != nil {
-			t.Errorf("%d: encode error %s:", i, err)
-			continue
-		}
-		dec := NewDecoder(b)
-		err = dec.Decode(test.out)
-		if err != nil {
-			t.Errorf("%d: decode error: %s", i, err)
-			continue
-		}
-		// Now see if the encoder and decoder are in a consistent state.
-		str := fmt.Sprintf("Value %d", i)
-		err = enc.Encode(&NewType0{str})
-		if err != nil {
-			t.Fatalf("%d: NewType0 encode error: %s", i, err)
-		}
-		ns := new(NewType0)
-		err = dec.Decode(ns)
-		if err != nil {
-			t.Fatalf("%d: NewType0 decode error: %s", i, err)
-		}
-		if ns.S != str {
-			t.Fatalf("%d: expected %q got %q", i, str, ns.S)
-		}
-	}
-}
-
-// Another bug from golang-nuts, involving nested interfaces.
-type Bug0Outer struct {
-	Bug0Field interface{}
-}
-
-type Bug0Inner struct {
-	A int
-}
-
-func TestNestedInterfaces(t *testing.T) {
-	var buf bytes.Buffer
-	e := NewEncoder(&buf)
-	d := NewDecoder(&buf)
-	Register(new(Bug0Outer))
-	Register(new(Bug0Inner))
-	f := &Bug0Outer{&Bug0Outer{&Bug0Inner{7}}}
-	var v interface{} = f
-	err := e.Encode(&v)
-	if err != nil {
-		t.Fatal("Encode:", err)
-	}
-	err = d.Decode(&v)
-	if err != nil {
-		t.Fatal("Decode:", err)
-	}
-	// Make sure it decoded correctly.
-	outer1, ok := v.(*Bug0Outer)
-	if !ok {
-		t.Fatalf("v not Bug0Outer: %T", v)
-	}
-	outer2, ok := outer1.Bug0Field.(*Bug0Outer)
-	if !ok {
-		t.Fatalf("v.Bug0Field not Bug0Outer: %T", outer1.Bug0Field)
-	}
-	inner, ok := outer2.Bug0Field.(*Bug0Inner)
-	if !ok {
-		t.Fatalf("v.Bug0Field.Bug0Field not Bug0Inner: %T", outer2.Bug0Field)
-	}
-	if inner.A != 7 {
-		t.Fatalf("final value %d; expected %d", inner.A, 7)
-	}
-}
-
-// The bugs keep coming. We forgot to send map subtypes before the map.
-
-type Bug1Elem struct {
-	Name string
-	Id   int
-}
-
-type Bug1StructMap map[string]Bug1Elem
-
-func bug1EncDec(in Bug1StructMap, out *Bug1StructMap) os.Error {
-	return nil
-}
-
-func TestMapBug1(t *testing.T) {
-	in := make(Bug1StructMap)
-	in["val1"] = Bug1Elem{"elem1", 1}
-	in["val2"] = Bug1Elem{"elem2", 2}
-
-	b := new(bytes.Buffer)
-	enc := NewEncoder(b)
-	err := enc.Encode(in)
-	if err != nil {
-		t.Fatal("encode:", err)
-	}
-	dec := NewDecoder(b)
-	out := make(Bug1StructMap)
-	err = dec.Decode(&out)
-	if err != nil {
-		t.Fatal("decode:", err)
-	}
-	if !reflect.DeepEqual(in, out) {
-		t.Errorf("mismatch: %v %v", in, out)
-	}
-}