Subversion Repositories openrisc

// 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"
        "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 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("", io.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{}) 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 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, "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)
                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) 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)
        }
}

func TestGobMapInterfaceEncode(t *testing.T) {
        m := map[string]interface{}{
                "up": uintptr(0),
                "i0": []int{-1},
                "i1": []int8{-1},
                "i2": []int16{-1},
                "i3": []int32{-1},
                "i4": []int64{-1},
                "u0": []uint{1},
                "u1": []uint8{1},
                "u2": []uint16{1},
                "u3": []uint32{1},
                "u4": []uint64{1},
                "f0": []float32{1},
                "f1": []float64{1},
                "c0": []complex64{complex(2, -2)},
                "c1": []complex128{complex(2, float64(-2))},
                "us": []uintptr{0},
                "bo": []bool{false},
                "st": []string{"s"},
        }
        enc := NewEncoder(new(bytes.Buffer))
        err := enc.Encode(m)
        if err != nil {
                t.Errorf("encode map: %s", err)
        }
}

func TestSliceReusesMemory(t *testing.T) {
        buf := new(bytes.Buffer)
        // Bytes
        {
                x := []byte("abcd")
                enc := NewEncoder(buf)
                err := enc.Encode(x)
                if err != nil {
                        t.Errorf("bytes: encode: %s", err)
                }
                // Decode into y, which is big enough.
                y := []byte("ABCDE")
                addr := &y[0]
                dec := NewDecoder(buf)
                err = dec.Decode(&y)
                if err != nil {
                        t.Fatal("bytes: decode:", err)
                }
                if !bytes.Equal(x, y) {
                        t.Errorf("bytes: expected %q got %q\n", x, y)
                }
                if addr != &y[0] {
                        t.Errorf("bytes: unnecessary reallocation")
                }
        }
        // general slice
        {
                x := []rune("abcd")
                enc := NewEncoder(buf)
                err := enc.Encode(x)
                if err != nil {
                        t.Errorf("ints: encode: %s", err)
                }
                // Decode into y, which is big enough.
                y := []rune("ABCDE")
                addr := &y[0]
                dec := NewDecoder(buf)
                err = dec.Decode(&y)
                if err != nil {
                        t.Fatal("ints: decode:", err)
                }
                if !reflect.DeepEqual(x, y) {
                        t.Errorf("ints: expected %q got %q\n", x, y)
                }
                if addr != &y[0] {
                        t.Errorf("ints: unnecessary reallocation")
                }
        }
}

// Used to crash: negative count in recvMessage.
func TestBadCount(t *testing.T) {
        b := []byte{0xfb, 0xa5, 0x82, 0x2f, 0xca, 0x1}
        if err := NewDecoder(bytes.NewBuffer(b)).Decode(nil); err == nil {
                t.Error("expected error from bad count")
        } else if err.Error() != errBadCount.Error() {
                t.Error("expected bad count error; got", err)
        }
}

// Verify that sequential Decoders built on a single input will
// succeed if the input implements ReadByte and there is no
// type information in the stream.
func TestSequentialDecoder(t *testing.T) {
        b := new(bytes.Buffer)
        enc := NewEncoder(b)
        const count = 10
        for i := 0; i < count; i++ {
                s := fmt.Sprintf("%d", i)
                if err := enc.Encode(s); err != nil {
                        t.Error("encoder fail:", err)
                }
        }
        for i := 0; i < count; i++ {
                dec := NewDecoder(b)
                var s string
                if err := dec.Decode(&s); err != nil {
                        t.Fatal("decoder fail:", err)
                }
                if s != fmt.Sprintf("%d", i) {
                        t.Fatalf("decode expected %d got %s", i, s)
                }
        }
}

// Should be able to have unrepresentable fields (chan, func) as long as they
// are unexported.
type Bug2 struct {
        A int
        b chan int
}

func TestUnexportedChan(t *testing.T) {
        b := Bug2{23, make(chan int)}
        var stream bytes.Buffer
        enc := NewEncoder(&stream)
        if err := enc.Encode(b); err != nil {
                t.Fatalf("error encoding unexported channel: %s", err)
        }
}

func TestSliceIncompatibility(t *testing.T) {
        var in = []byte{1, 2, 3}
        var out []int
        if err := encAndDec(in, &out); err == nil {
                t.Error("expected compatibility error")
        }
}