| // 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" |
| "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 float |
| 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.Error("expected error", err, "got", 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 := (*Type0)(nil) |
| 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 ****float |
| } |
| t2 := Type2{} |
| t2.a = new(***float) |
| *t2.a = new(**float) |
| **t2.a = new(*float) |
| ***t2.a = new(float) |
| ****t2.a = 27.4 |
| t2pppp := new(***Type2) |
| if err := encAndDec(t2, t2pppp); err != nil { |
| t.Error(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") |
| } |
| } |
| |
| // 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 []float |
| } |
| t7 := Type7{ |
| []bool{false, false, true}, |
| []int{0, 0, 1}, |
| []string{"hi", "", "there"}, |
| []float{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.NewValue(test.out).(*reflect.PtrValue).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) |
| } |
| } |