blob: 3d49887c016767805c704a398c37b86fd5520b0c [file] [log] [blame]
// Copyright 2011 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 contains tests of the GobEncoder/GobDecoder support.
package gob
import (
"bytes"
"errors"
"fmt"
"io"
"net"
"reflect"
"strings"
"testing"
"time"
)
// Types that implement the GobEncoder/Decoder interfaces.
type ByteStruct struct {
a byte // not an exported field
}
type StringStruct struct {
s string // not an exported field
}
type ArrayStruct struct {
a [8192]byte // not an exported field
}
type Gobber int
type ValueGobber string // encodes with a value, decodes with a pointer.
type BinaryGobber int
type BinaryValueGobber string
type TextGobber int
type TextValueGobber string
// The relevant methods
func (g *ByteStruct) GobEncode() ([]byte, error) {
b := make([]byte, 3)
b[0] = g.a
b[1] = g.a + 1
b[2] = g.a + 2
return b, nil
}
func (g *ByteStruct) GobDecode(data []byte) error {
if g == nil {
return errors.New("NIL RECEIVER")
}
// Expect N sequential-valued bytes.
if len(data) == 0 {
return io.EOF
}
g.a = data[0]
for i, c := range data {
if c != g.a+byte(i) {
return errors.New("invalid data sequence")
}
}
return nil
}
func (g *StringStruct) GobEncode() ([]byte, error) {
return []byte(g.s), nil
}
func (g *StringStruct) GobDecode(data []byte) error {
// Expect N sequential-valued bytes.
if len(data) == 0 {
return io.EOF
}
a := data[0]
for i, c := range data {
if c != a+byte(i) {
return errors.New("invalid data sequence")
}
}
g.s = string(data)
return nil
}
func (a *ArrayStruct) GobEncode() ([]byte, error) {
return a.a[:], nil
}
func (a *ArrayStruct) GobDecode(data []byte) error {
if len(data) != len(a.a) {
return errors.New("wrong length in array decode")
}
copy(a.a[:], data)
return nil
}
func (g *Gobber) GobEncode() ([]byte, error) {
return []byte(fmt.Sprintf("VALUE=%d", *g)), nil
}
func (g *Gobber) GobDecode(data []byte) error {
_, err := fmt.Sscanf(string(data), "VALUE=%d", (*int)(g))
return err
}
func (g *BinaryGobber) MarshalBinary() ([]byte, error) {
return []byte(fmt.Sprintf("VALUE=%d", *g)), nil
}
func (g *BinaryGobber) UnmarshalBinary(data []byte) error {
_, err := fmt.Sscanf(string(data), "VALUE=%d", (*int)(g))
return err
}
func (g *TextGobber) MarshalText() ([]byte, error) {
return []byte(fmt.Sprintf("VALUE=%d", *g)), nil
}
func (g *TextGobber) UnmarshalText(data []byte) error {
_, err := fmt.Sscanf(string(data), "VALUE=%d", (*int)(g))
return err
}
func (v ValueGobber) GobEncode() ([]byte, error) {
return []byte(fmt.Sprintf("VALUE=%s", v)), nil
}
func (v *ValueGobber) GobDecode(data []byte) error {
_, err := fmt.Sscanf(string(data), "VALUE=%s", (*string)(v))
return err
}
func (v BinaryValueGobber) MarshalBinary() ([]byte, error) {
return []byte(fmt.Sprintf("VALUE=%s", v)), nil
}
func (v *BinaryValueGobber) UnmarshalBinary(data []byte) error {
_, err := fmt.Sscanf(string(data), "VALUE=%s", (*string)(v))
return err
}
func (v TextValueGobber) MarshalText() ([]byte, error) {
return []byte(fmt.Sprintf("VALUE=%s", v)), nil
}
func (v *TextValueGobber) UnmarshalText(data []byte) error {
_, err := fmt.Sscanf(string(data), "VALUE=%s", (*string)(v))
return err
}
// Structs that include GobEncodable fields.
type GobTest0 struct {
X int // guarantee we have something in common with GobTest*
G *ByteStruct
}
type GobTest1 struct {
X int // guarantee we have something in common with GobTest*
G *StringStruct
}
type GobTest2 struct {
X int // guarantee we have something in common with GobTest*
G string // not a GobEncoder - should give us errors
}
type GobTest3 struct {
X int // guarantee we have something in common with GobTest*
G *Gobber
B *BinaryGobber
T *TextGobber
}
type GobTest4 struct {
X int // guarantee we have something in common with GobTest*
V ValueGobber
BV BinaryValueGobber
TV TextValueGobber
}
type GobTest5 struct {
X int // guarantee we have something in common with GobTest*
V *ValueGobber
BV *BinaryValueGobber
TV *TextValueGobber
}
type GobTest6 struct {
X int // guarantee we have something in common with GobTest*
V ValueGobber
W *ValueGobber
BV BinaryValueGobber
BW *BinaryValueGobber
TV TextValueGobber
TW *TextValueGobber
}
type GobTest7 struct {
X int // guarantee we have something in common with GobTest*
V *ValueGobber
W ValueGobber
BV *BinaryValueGobber
BW BinaryValueGobber
TV *TextValueGobber
TW TextValueGobber
}
type GobTestIgnoreEncoder struct {
X int // guarantee we have something in common with GobTest*
}
type GobTestValueEncDec struct {
X int // guarantee we have something in common with GobTest*
G StringStruct // not a pointer.
}
type GobTestIndirectEncDec struct {
X int // guarantee we have something in common with GobTest*
G ***StringStruct // indirections to the receiver.
}
type GobTestArrayEncDec struct {
X int // guarantee we have something in common with GobTest*
A ArrayStruct // not a pointer.
}
type GobTestIndirectArrayEncDec struct {
X int // guarantee we have something in common with GobTest*
A ***ArrayStruct // indirections to a large receiver.
}
func TestGobEncoderField(t *testing.T) {
b := new(bytes.Buffer)
// First a field that's a structure.
enc := NewEncoder(b)
err := enc.Encode(GobTest0{17, &ByteStruct{'A'}})
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTest0)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
if x.G.a != 'A' {
t.Errorf("expected 'A' got %c", x.G.a)
}
// Now a field that's not a structure.
b.Reset()
gobber := Gobber(23)
bgobber := BinaryGobber(24)
tgobber := TextGobber(25)
err = enc.Encode(GobTest3{17, &gobber, &bgobber, &tgobber})
if err != nil {
t.Fatal("encode error:", err)
}
y := new(GobTest3)
err = dec.Decode(y)
if err != nil {
t.Fatal("decode error:", err)
}
if *y.G != 23 || *y.B != 24 || *y.T != 25 {
t.Errorf("expected '23 got %d", *y.G)
}
}
// Even though the field is a value, we can still take its address
// and should be able to call the methods.
func TestGobEncoderValueField(t *testing.T) {
b := new(bytes.Buffer)
// First a field that's a structure.
enc := NewEncoder(b)
err := enc.Encode(&GobTestValueEncDec{17, StringStruct{"HIJKL"}})
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTestValueEncDec)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
if x.G.s != "HIJKL" {
t.Errorf("expected `HIJKL` got %s", x.G.s)
}
}
// GobEncode/Decode should work even if the value is
// more indirect than the receiver.
func TestGobEncoderIndirectField(t *testing.T) {
b := new(bytes.Buffer)
// First a field that's a structure.
enc := NewEncoder(b)
s := &StringStruct{"HIJKL"}
sp := &s
err := enc.Encode(GobTestIndirectEncDec{17, &sp})
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTestIndirectEncDec)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
if (***x.G).s != "HIJKL" {
t.Errorf("expected `HIJKL` got %s", (***x.G).s)
}
}
// Test with a large field with methods.
func TestGobEncoderArrayField(t *testing.T) {
b := new(bytes.Buffer)
enc := NewEncoder(b)
var a GobTestArrayEncDec
a.X = 17
for i := range a.A.a {
a.A.a[i] = byte(i)
}
err := enc.Encode(&a)
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTestArrayEncDec)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
for i, v := range x.A.a {
if v != byte(i) {
t.Errorf("expected %x got %x", byte(i), v)
break
}
}
}
// Test an indirection to a large field with methods.
func TestGobEncoderIndirectArrayField(t *testing.T) {
b := new(bytes.Buffer)
enc := NewEncoder(b)
var a GobTestIndirectArrayEncDec
a.X = 17
var array ArrayStruct
ap := &array
app := &ap
a.A = &app
for i := range array.a {
array.a[i] = byte(i)
}
err := enc.Encode(a)
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTestIndirectArrayEncDec)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
for i, v := range (***x.A).a {
if v != byte(i) {
t.Errorf("expected %x got %x", byte(i), v)
break
}
}
}
// As long as the fields have the same name and implement the
// interface, we can cross-connect them. Not sure it's useful
// and may even be bad but it works and it's hard to prevent
// without exposing the contents of the object, which would
// defeat the purpose.
func TestGobEncoderFieldsOfDifferentType(t *testing.T) {
// first, string in field to byte in field
b := new(bytes.Buffer)
enc := NewEncoder(b)
err := enc.Encode(GobTest1{17, &StringStruct{"ABC"}})
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTest0)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
if x.G.a != 'A' {
t.Errorf("expected 'A' got %c", x.G.a)
}
// now the other direction, byte in field to string in field
b.Reset()
err = enc.Encode(GobTest0{17, &ByteStruct{'X'}})
if err != nil {
t.Fatal("encode error:", err)
}
y := new(GobTest1)
err = dec.Decode(y)
if err != nil {
t.Fatal("decode error:", err)
}
if y.G.s != "XYZ" {
t.Fatalf("expected `XYZ` got %q", y.G.s)
}
}
// Test that we can encode a value and decode into a pointer.
func TestGobEncoderValueEncoder(t *testing.T) {
// first, string in field to byte in field
b := new(bytes.Buffer)
enc := NewEncoder(b)
err := enc.Encode(GobTest4{17, ValueGobber("hello"), BinaryValueGobber("Καλημέρα"), TextValueGobber("こんにちは")})
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTest5)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
if *x.V != "hello" || *x.BV != "Καλημέρα" || *x.TV != "こんにちは" {
t.Errorf("expected `hello` got %s", *x.V)
}
}
// Test that we can use a value then a pointer type of a GobEncoder
// in the same encoded value. Bug 4647.
func TestGobEncoderValueThenPointer(t *testing.T) {
v := ValueGobber("forty-two")
w := ValueGobber("six-by-nine")
bv := BinaryValueGobber("1nanocentury")
bw := BinaryValueGobber("πseconds")
tv := TextValueGobber("gravitationalacceleration")
tw := TextValueGobber("π²ft/s²")
// this was a bug: encoding a GobEncoder by value before a GobEncoder
// pointer would cause duplicate type definitions to be sent.
b := new(bytes.Buffer)
enc := NewEncoder(b)
if err := enc.Encode(GobTest6{42, v, &w, bv, &bw, tv, &tw}); err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTest6)
if err := dec.Decode(x); err != nil {
t.Fatal("decode error:", err)
}
if got, want := x.V, v; got != want {
t.Errorf("v = %q, want %q", got, want)
}
if got, want := x.W, w; got == nil {
t.Errorf("w = nil, want %q", want)
} else if *got != want {
t.Errorf("w = %q, want %q", *got, want)
}
if got, want := x.BV, bv; got != want {
t.Errorf("bv = %q, want %q", got, want)
}
if got, want := x.BW, bw; got == nil {
t.Errorf("bw = nil, want %q", want)
} else if *got != want {
t.Errorf("bw = %q, want %q", *got, want)
}
if got, want := x.TV, tv; got != want {
t.Errorf("tv = %q, want %q", got, want)
}
if got, want := x.TW, tw; got == nil {
t.Errorf("tw = nil, want %q", want)
} else if *got != want {
t.Errorf("tw = %q, want %q", *got, want)
}
}
// Test that we can use a pointer then a value type of a GobEncoder
// in the same encoded value.
func TestGobEncoderPointerThenValue(t *testing.T) {
v := ValueGobber("forty-two")
w := ValueGobber("six-by-nine")
bv := BinaryValueGobber("1nanocentury")
bw := BinaryValueGobber("πseconds")
tv := TextValueGobber("gravitationalacceleration")
tw := TextValueGobber("π²ft/s²")
b := new(bytes.Buffer)
enc := NewEncoder(b)
if err := enc.Encode(GobTest7{42, &v, w, &bv, bw, &tv, tw}); err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTest7)
if err := dec.Decode(x); err != nil {
t.Fatal("decode error:", err)
}
if got, want := x.V, v; got == nil {
t.Errorf("v = nil, want %q", want)
} else if *got != want {
t.Errorf("v = %q, want %q", *got, want)
}
if got, want := x.W, w; got != want {
t.Errorf("w = %q, want %q", got, want)
}
if got, want := x.BV, bv; got == nil {
t.Errorf("bv = nil, want %q", want)
} else if *got != want {
t.Errorf("bv = %q, want %q", *got, want)
}
if got, want := x.BW, bw; got != want {
t.Errorf("bw = %q, want %q", got, want)
}
if got, want := x.TV, tv; got == nil {
t.Errorf("tv = nil, want %q", want)
} else if *got != want {
t.Errorf("tv = %q, want %q", *got, want)
}
if got, want := x.TW, tw; got != want {
t.Errorf("tw = %q, want %q", got, want)
}
}
func TestGobEncoderFieldTypeError(t *testing.T) {
// GobEncoder to non-decoder: error
b := new(bytes.Buffer)
enc := NewEncoder(b)
err := enc.Encode(GobTest1{17, &StringStruct{"ABC"}})
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := &GobTest2{}
err = dec.Decode(x)
if err == nil {
t.Fatal("expected decode error for mismatched fields (encoder to non-decoder)")
}
if !strings.Contains(err.Error(), "type") {
t.Fatal("expected type error; got", err)
}
// Non-encoder to GobDecoder: error
b.Reset()
err = enc.Encode(GobTest2{17, "ABC"})
if err != nil {
t.Fatal("encode error:", err)
}
y := &GobTest1{}
err = dec.Decode(y)
if err == nil {
t.Fatal("expected decode error for mismatched fields (non-encoder to decoder)")
}
if !strings.Contains(err.Error(), "type") {
t.Fatal("expected type error; got", err)
}
}
// Even though ByteStruct is a struct, it's treated as a singleton at the top level.
func TestGobEncoderStructSingleton(t *testing.T) {
b := new(bytes.Buffer)
enc := NewEncoder(b)
err := enc.Encode(&ByteStruct{'A'})
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(ByteStruct)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
if x.a != 'A' {
t.Errorf("expected 'A' got %c", x.a)
}
}
func TestGobEncoderNonStructSingleton(t *testing.T) {
b := new(bytes.Buffer)
enc := NewEncoder(b)
var g Gobber = 1234
err := enc.Encode(&g)
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
var x Gobber
err = dec.Decode(&x)
if err != nil {
t.Fatal("decode error:", err)
}
if x != 1234 {
t.Errorf("expected 1234 got %d", x)
}
}
func TestGobEncoderIgnoreStructField(t *testing.T) {
b := new(bytes.Buffer)
// First a field that's a structure.
enc := NewEncoder(b)
err := enc.Encode(GobTest0{17, &ByteStruct{'A'}})
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTestIgnoreEncoder)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
if x.X != 17 {
t.Errorf("expected 17 got %c", x.X)
}
}
func TestGobEncoderIgnoreNonStructField(t *testing.T) {
b := new(bytes.Buffer)
// First a field that's a structure.
enc := NewEncoder(b)
gobber := Gobber(23)
bgobber := BinaryGobber(24)
tgobber := TextGobber(25)
err := enc.Encode(GobTest3{17, &gobber, &bgobber, &tgobber})
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTestIgnoreEncoder)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
if x.X != 17 {
t.Errorf("expected 17 got %c", x.X)
}
}
func TestGobEncoderIgnoreNilEncoder(t *testing.T) {
b := new(bytes.Buffer)
// First a field that's a structure.
enc := NewEncoder(b)
err := enc.Encode(GobTest0{X: 18}) // G is nil
if err != nil {
t.Fatal("encode error:", err)
}
dec := NewDecoder(b)
x := new(GobTest0)
err = dec.Decode(x)
if err != nil {
t.Fatal("decode error:", err)
}
if x.X != 18 {
t.Errorf("expected x.X = 18, got %v", x.X)
}
if x.G != nil {
t.Errorf("expected x.G = nil, got %v", x.G)
}
}
type gobDecoderBug0 struct {
foo, bar string
}
func (br *gobDecoderBug0) String() string {
return br.foo + "-" + br.bar
}
func (br *gobDecoderBug0) GobEncode() ([]byte, error) {
return []byte(br.String()), nil
}
func (br *gobDecoderBug0) GobDecode(b []byte) error {
br.foo = "foo"
br.bar = "bar"
return nil
}
// This was a bug: the receiver has a different indirection level
// than the variable.
func TestGobEncoderExtraIndirect(t *testing.T) {
gdb := &gobDecoderBug0{"foo", "bar"}
buf := new(bytes.Buffer)
e := NewEncoder(buf)
if err := e.Encode(gdb); err != nil {
t.Fatalf("encode: %v", err)
}
d := NewDecoder(buf)
var got *gobDecoderBug0
if err := d.Decode(&got); err != nil {
t.Fatalf("decode: %v", err)
}
if got.foo != gdb.foo || got.bar != gdb.bar {
t.Errorf("got = %q, want %q", got, gdb)
}
}
// Another bug: this caused a crash with the new Go1 Time type.
// We throw in a gob-encoding array, to test another case of isZero,
// and a struct containing a nil interface, to test a third.
type isZeroBug struct {
T time.Time
S string
I int
A isZeroBugArray
F isZeroBugInterface
}
type isZeroBugArray [2]uint8
// Receiver is value, not pointer, to test isZero of array.
func (a isZeroBugArray) GobEncode() (b []byte, e error) {
b = append(b, a[:]...)
return b, nil
}
func (a *isZeroBugArray) GobDecode(data []byte) error {
if len(data) != len(a) {
return io.EOF
}
a[0] = data[0]
a[1] = data[1]
return nil
}
type isZeroBugInterface struct {
I any
}
func (i isZeroBugInterface) GobEncode() (b []byte, e error) {
return []byte{}, nil
}
func (i *isZeroBugInterface) GobDecode(data []byte) error {
return nil
}
func TestGobEncodeIsZero(t *testing.T) {
x := isZeroBug{time.Unix(1e9, 0), "hello", -55, isZeroBugArray{1, 2}, isZeroBugInterface{}}
b := new(bytes.Buffer)
enc := NewEncoder(b)
err := enc.Encode(x)
if err != nil {
t.Fatal("encode:", err)
}
var y isZeroBug
dec := NewDecoder(b)
err = dec.Decode(&y)
if err != nil {
t.Fatal("decode:", err)
}
if x != y {
t.Fatalf("%v != %v", x, y)
}
}
func TestGobEncodePtrError(t *testing.T) {
var err error
b := new(bytes.Buffer)
enc := NewEncoder(b)
err = enc.Encode(&err)
if err != nil {
t.Fatal("encode:", err)
}
dec := NewDecoder(b)
err2 := fmt.Errorf("foo")
err = dec.Decode(&err2)
if err != nil {
t.Fatal("decode:", err)
}
if err2 != nil {
t.Fatalf("expected nil, got %v", err2)
}
}
func TestNetIP(t *testing.T) {
// Encoding of net.IP{1,2,3,4} in Go 1.1.
enc := []byte{0x07, 0x0a, 0x00, 0x04, 0x01, 0x02, 0x03, 0x04}
var ip net.IP
err := NewDecoder(bytes.NewReader(enc)).Decode(&ip)
if err != nil {
t.Fatalf("decode: %v", err)
}
if ip.String() != "1.2.3.4" {
t.Errorf("decoded to %v, want 1.2.3.4", ip.String())
}
}
func TestIngoreDepthLimit(t *testing.T) {
// We don't test the actual depth limit because it requires building an
// extremely large message, which takes quite a while.
oldNestingDepth := maxIgnoreNestingDepth
maxIgnoreNestingDepth = 100
defer func() { maxIgnoreNestingDepth = oldNestingDepth }()
b := new(bytes.Buffer)
enc := NewEncoder(b)
typ := reflect.TypeOf(int(0))
nested := reflect.ArrayOf(1, typ)
for i := 0; i < 100; i++ {
nested = reflect.ArrayOf(1, nested)
}
badStruct := reflect.New(reflect.StructOf([]reflect.StructField{{Name: "F", Type: nested}}))
enc.Encode(badStruct.Interface())
dec := NewDecoder(b)
var output struct{ Hello int }
expectedErr := "invalid nesting depth"
if err := dec.Decode(&output); err == nil || err.Error() != expectedErr {
t.Errorf("Decode didn't fail with depth limit of 100: want %q, got %q", expectedErr, err)
}
}