libgo/go/gob/encoder_test.go

   1 // Copyright 2009 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package gob
   6
   7 import (
   8         "bytes"
   9         "fmt"
  10         "io"
  11         "os"
  12         "reflect"
  13         "strings"
  14         "testing"
  15 )
  16
  17 type ET2 struct {
  18         X string
  19 }
  20
  21 type ET1 struct {
  22         A    int
  23         Et2  *ET2
  24         Next *ET1
  25 }
  26
  27 // Like ET1 but with a different name for a field
  28 type ET3 struct {
  29         A             int
  30         Et2           *ET2
  31         DifferentNext *ET1
  32 }
  33
  34 // Like ET1 but with a different type for a field
  35 type ET4 struct {
  36         A    int
  37         Et2  float64
  38         Next int
  39 }
  40
  41 func TestEncoderDecoder(t *testing.T) {
  42         b := new(bytes.Buffer)
  43         enc := NewEncoder(b)
  44         et1 := new(ET1)
  45         et1.A = 7
  46         et1.Et2 = new(ET2)
  47         err := enc.Encode(et1)
  48         if err != nil {
  49                 t.Error("encoder fail:", err)
  50         }
  51         dec := NewDecoder(b)
  52         newEt1 := new(ET1)
  53         err = dec.Decode(newEt1)
  54         if err != nil {
  55                 t.Fatal("error decoding ET1:", err)
  56         }
  57
  58         if !reflect.DeepEqual(et1, newEt1) {
  59                 t.Fatalf("invalid data for et1: expected %+v; got %+v", *et1, *newEt1)
  60         }
  61         if b.Len() != 0 {
  62                 t.Error("not at eof;", b.Len(), "bytes left")
  63         }
  64
  65         enc.Encode(et1)
  66         newEt1 = new(ET1)
  67         err = dec.Decode(newEt1)
  68         if err != nil {
  69                 t.Fatal("round 2: error decoding ET1:", err)
  70         }
  71         if !reflect.DeepEqual(et1, newEt1) {
  72                 t.Fatalf("round 2: invalid data for et1: expected %+v; got %+v", *et1, *newEt1)
  73         }
  74         if b.Len() != 0 {
  75                 t.Error("round 2: not at eof;", b.Len(), "bytes left")
  76         }
  77
  78         // Now test with a running encoder/decoder pair that we recognize a type mismatch.
  79         err = enc.Encode(et1)
  80         if err != nil {
  81                 t.Error("round 3: encoder fail:", err)
  82         }
  83         newEt2 := new(ET2)
  84         err = dec.Decode(newEt2)
  85         if err == nil {
  86                 t.Fatal("round 3: expected `bad type' error decoding ET2")
  87         }
  88 }
  89
  90 // Run one value through the encoder/decoder, but use the wrong type.
  91 // Input is always an ET1; we compare it to whatever is under 'e'.
  92 func badTypeCheck(e interface{}, shouldFail bool, msg string, t *testing.T) {
  93         b := new(bytes.Buffer)
  94         enc := NewEncoder(b)
  95         et1 := new(ET1)
  96         et1.A = 7
  97         et1.Et2 = new(ET2)
  98         err := enc.Encode(et1)
  99         if err != nil {
 100                 t.Error("encoder fail:", err)
 101         }
 102         dec := NewDecoder(b)
 103         err = dec.Decode(e)
 104         if shouldFail && err == nil {
 105                 t.Error("expected error for", msg)
 106         }
 107         if !shouldFail && err != nil {
 108                 t.Error("unexpected error for", msg, err)
 109         }
 110 }
 111
 112 // Test that we recognize a bad type the first time.
 113 func TestWrongTypeDecoder(t *testing.T) {
 114         badTypeCheck(new(ET2), true, "no fields in common", t)
 115         badTypeCheck(new(ET3), false, "different name of field", t)
 116         badTypeCheck(new(ET4), true, "different type of field", t)
 117 }
 118
 119 func corruptDataCheck(s string, err os.Error, t *testing.T) {
 120         b := bytes.NewBufferString(s)
 121         dec := NewDecoder(b)
 122         err1 := dec.Decode(new(ET2))
 123         if err1 != err {
 124                 t.Errorf("from %q expected error %s; got %s", s, err, err1)
 125         }
 126 }
 127
 128 // Check that we survive bad data.
 129 func TestBadData(t *testing.T) {
 130         corruptDataCheck("", os.EOF, t)
 131         corruptDataCheck("\x7Fhi", io.ErrUnexpectedEOF, t)
 132         corruptDataCheck("\x03now is the time for all good men", errBadType, t)
 133 }
 134
 135 // Types not supported by the Encoder.
 136 var unsupportedValues = []interface{}{
 137         make(chan int),
 138         func(a int) bool { return true },
 139 }
 140
 141 func TestUnsupported(t *testing.T) {
 142         var b bytes.Buffer
 143         enc := NewEncoder(&b)
 144         for _, v := range unsupportedValues {
 145                 err := enc.Encode(v)
 146                 if err == nil {
 147                         t.Errorf("expected error for %T; got none", v)
 148                 }
 149         }
 150 }
 151
 152 func encAndDec(in, out interface{}) os.Error {
 153         b := new(bytes.Buffer)
 154         enc := NewEncoder(b)
 155         err := enc.Encode(in)
 156         if err != nil {
 157                 return err
 158         }
 159         dec := NewDecoder(b)
 160         err = dec.Decode(out)
 161         if err != nil {
 162                 return err
 163         }
 164         return nil
 165 }
 166
 167 func TestTypeToPtrType(t *testing.T) {
 168         // Encode a T, decode a *T
 169         type Type0 struct {
 170                 A int
 171         }
 172         t0 := Type0{7}
 173         t0p := (*Type0)(nil)
 174         if err := encAndDec(t0, t0p); err != nil {
 175                 t.Error(err)
 176         }
 177 }
 178
 179 func TestPtrTypeToType(t *testing.T) {
 180         // Encode a *T, decode a T
 181         type Type1 struct {
 182                 A uint
 183         }
 184         t1p := &Type1{17}
 185         var t1 Type1
 186         if err := encAndDec(t1, t1p); err != nil {
 187                 t.Error(err)
 188         }
 189 }
 190
 191 func TestTypeToPtrPtrPtrPtrType(t *testing.T) {
 192         type Type2 struct {
 193                 A ****float64
 194         }
 195         t2 := Type2{}
 196         t2.A = new(***float64)
 197         *t2.A = new(**float64)
 198         **t2.A = new(*float64)
 199         ***t2.A = new(float64)
 200         ****t2.A = 27.4
 201         t2pppp := new(***Type2)
 202         if err := encAndDec(t2, t2pppp); err != nil {
 203                 t.Fatal(err)
 204         }
 205         if ****(****t2pppp).A != ****t2.A {
 206                 t.Errorf("wrong value after decode: %g not %g", ****(****t2pppp).A, ****t2.A)
 207         }
 208 }
 209
 210 func TestSlice(t *testing.T) {
 211         type Type3 struct {
 212                 A []string
 213         }
 214         t3p := &Type3{[]string{"hello", "world"}}
 215         var t3 Type3
 216         if err := encAndDec(t3, t3p); err != nil {
 217                 t.Error(err)
 218         }
 219 }
 220
 221 func TestValueError(t *testing.T) {
 222         // Encode a *T, decode a T
 223         type Type4 struct {
 224                 A int
 225         }
 226         t4p := &Type4{3}
 227         var t4 Type4 // note: not a pointer.
 228         if err := encAndDec(t4p, t4); err == nil || strings.Index(err.String(), "pointer") < 0 {
 229                 t.Error("expected error about pointer; got", err)
 230         }
 231 }
 232
 233 func TestArray(t *testing.T) {
 234         type Type5 struct {
 235                 A [3]string
 236                 B [3]byte
 237         }
 238         type Type6 struct {
 239                 A [2]string // can't hold t5.a
 240         }
 241         t5 := Type5{[3]string{"hello", ",", "world"}, [3]byte{1, 2, 3}}
 242         var t5p Type5
 243         if err := encAndDec(t5, &t5p); err != nil {
 244                 t.Error(err)
 245         }
 246         var t6 Type6
 247         if err := encAndDec(t5, &t6); err == nil {
 248                 t.Error("should fail with mismatched array sizes")
 249         }
 250 }
 251
 252 func TestRecursiveMapType(t *testing.T) {
 253         type recursiveMap map[string]recursiveMap
 254         r1 := recursiveMap{"A": recursiveMap{"B": nil, "C": nil}, "D": nil}
 255         r2 := make(recursiveMap)
 256         if err := encAndDec(r1, &r2); err != nil {
 257                 t.Error(err)
 258         }
 259 }
 260
 261 func TestRecursiveSliceType(t *testing.T) {
 262         type recursiveSlice []recursiveSlice
 263         r1 := recursiveSlice{0: recursiveSlice{0: nil}, 1: nil}
 264         r2 := make(recursiveSlice, 0)
 265         if err := encAndDec(r1, &r2); err != nil {
 266                 t.Error(err)
 267         }
 268 }
 269
 270 // Regression test for bug: must send zero values inside arrays
 271 func TestDefaultsInArray(t *testing.T) {
 272         type Type7 struct {
 273                 B []bool
 274                 I []int
 275                 S []string
 276                 F []float64
 277         }
 278         t7 := Type7{
 279                 []bool{false, false, true},
 280                 []int{0, 0, 1},
 281                 []string{"hi", "", "there"},
 282                 []float64{0, 0, 1},
 283         }
 284         var t7p Type7
 285         if err := encAndDec(t7, &t7p); err != nil {
 286                 t.Error(err)
 287         }
 288 }
 289
 290 var testInt int
 291 var testFloat32 float32
 292 var testString string
 293 var testSlice []string
 294 var testMap map[string]int
 295 var testArray [7]int
 296
 297 type SingleTest struct {
 298         in  interface{}
 299         out interface{}
 300         err string
 301 }
 302
 303 var singleTests = []SingleTest{
 304         {17, &testInt, ""},
 305         {float32(17.5), &testFloat32, ""},
 306         {"bike shed", &testString, ""},
 307         {[]string{"bike", "shed", "paint", "color"}, &testSlice, ""},
 308         {map[string]int{"seven": 7, "twelve": 12}, &testMap, ""},
 309         {[7]int{4, 55, 0, 0, 0, 0, 0}, &testArray, ""}, // case that once triggered a bug
 310         {[7]int{4, 55, 1, 44, 22, 66, 1234}, &testArray, ""},
 311
 312         // Decode errors
 313         {172, &testFloat32, "wrong type"},
 314 }
 315
 316 func TestSingletons(t *testing.T) {
 317         b := new(bytes.Buffer)
 318         enc := NewEncoder(b)
 319         dec := NewDecoder(b)
 320         for _, test := range singleTests {
 321                 b.Reset()
 322                 err := enc.Encode(test.in)
 323                 if err != nil {
 324                         t.Errorf("error encoding %v: %s", test.in, err)
 325                         continue
 326                 }
 327                 err = dec.Decode(test.out)
 328                 switch {
 329                 case err != nil && test.err == "":
 330                         t.Errorf("error decoding %v: %s", test.in, err)
 331                         continue
 332                 case err == nil && test.err != "":
 333                         t.Errorf("expected error decoding %v: %s", test.in, test.err)
 334                         continue
 335                 case err != nil && test.err != "":
 336                         if strings.Index(err.String(), test.err) < 0 {
 337                                 t.Errorf("wrong error decoding %v: wanted %s, got %v", test.in, test.err, err)
 338                         }
 339                         continue
 340                 }
 341                 // Get rid of the pointer in the rhs
 342                 val := reflect.NewValue(test.out).(*reflect.PtrValue).Elem().Interface()
 343                 if !reflect.DeepEqual(test.in, val) {
 344                         t.Errorf("decoding singleton: expected %v got %v", test.in, val)
 345                 }
 346         }
 347 }
 348
 349 func TestStructNonStruct(t *testing.T) {
 350         type Struct struct {
 351                 A string
 352         }
 353         type NonStruct string
 354         s := Struct{"hello"}
 355         var sp Struct
 356         if err := encAndDec(s, &sp); err != nil {
 357                 t.Error(err)
 358         }
 359         var ns NonStruct
 360         if err := encAndDec(s, &ns); err == nil {
 361                 t.Error("should get error for struct/non-struct")
 362         } else if strings.Index(err.String(), "type") < 0 {
 363                 t.Error("for struct/non-struct expected type error; got", err)
 364         }
 365         // Now try the other way
 366         var nsp NonStruct
 367         if err := encAndDec(ns, &nsp); err != nil {
 368                 t.Error(err)
 369         }
 370         if err := encAndDec(ns, &s); err == nil {
 371                 t.Error("should get error for non-struct/struct")
 372         } else if strings.Index(err.String(), "type") < 0 {
 373                 t.Error("for non-struct/struct expected type error; got", err)
 374         }
 375 }
 376
 377 type interfaceIndirectTestI interface {
 378         F() bool
 379 }
 380
 381 type interfaceIndirectTestT struct{}
 382
 383 func (this *interfaceIndirectTestT) F() bool {
 384         return true
 385 }
 386
 387 // A version of a bug reported on golang-nuts.  Also tests top-level
 388 // slice of interfaces.  The issue was registering *T caused T to be
 389 // stored as the concrete type.
 390 func TestInterfaceIndirect(t *testing.T) {
 391         Register(&interfaceIndirectTestT{})
 392         b := new(bytes.Buffer)
 393         w := []interfaceIndirectTestI{&interfaceIndirectTestT{}}
 394         err := NewEncoder(b).Encode(w)
 395         if err != nil {
 396                 t.Fatal("encode error:", err)
 397         }
 398
 399         var r []interfaceIndirectTestI
 400         err = NewDecoder(b).Decode(&r)
 401         if err != nil {
 402                 t.Fatal("decode error:", err)
 403         }
 404 }
 405
 406 // Now follow various tests that decode into things that can't represent the
 407 // encoded value, all of which should be legal.
 408
 409 // Also, when the ignored object contains an interface value, it may define
 410 // types. Make sure that skipping the value still defines the types by using
 411 // the encoder/decoder pair to send a value afterwards.  If an interface
 412 // is sent, its type in the test is always NewType0, so this checks that the
 413 // encoder and decoder don't skew with respect to type definitions.
 414
 415 type Struct0 struct {
 416         I interface{}
 417 }
 418
 419 type NewType0 struct {
 420         S string
 421 }
 422
 423 type ignoreTest struct {
 424         in, out interface{}
 425 }
 426
 427 var ignoreTests = []ignoreTest{
 428         // Decode normal struct into an empty struct
 429         {&struct{ A int }{23}, &struct{}{}},
 430         // Decode normal struct into a nil.
 431         {&struct{ A int }{23}, nil},
 432         // Decode singleton string into a nil.
 433         {"hello, world", nil},
 434         // Decode singleton slice into a nil.
 435         {[]int{1, 2, 3, 4}, nil},
 436         // Decode struct containing an interface into a nil.
 437         {&Struct0{&NewType0{"value0"}}, nil},
 438         // Decode singleton slice of interfaces into a nil.
 439         {[]interface{}{"hi", &NewType0{"value1"}, 23}, nil},
 440 }
 441
 442 func TestDecodeIntoNothing(t *testing.T) {
 443         Register(new(NewType0))
 444         for i, test := range ignoreTests {
 445                 b := new(bytes.Buffer)
 446                 enc := NewEncoder(b)
 447                 err := enc.Encode(test.in)
 448                 if err != nil {
 449                         t.Errorf("%d: encode error %s:", i, err)
 450                         continue
 451                 }
 452                 dec := NewDecoder(b)
 453                 err = dec.Decode(test.out)
 454                 if err != nil {
 455                         t.Errorf("%d: decode error: %s", i, err)
 456                         continue
 457                 }
 458                 // Now see if the encoder and decoder are in a consistent state.
 459                 str := fmt.Sprintf("Value %d", i)
 460                 err = enc.Encode(&NewType0{str})
 461                 if err != nil {
 462                         t.Fatalf("%d: NewType0 encode error: %s", i, err)
 463                 }
 464                 ns := new(NewType0)
 465                 err = dec.Decode(ns)
 466                 if err != nil {
 467                         t.Fatalf("%d: NewType0 decode error: %s", i, err)
 468                 }
 469                 if ns.S != str {
 470                         t.Fatalf("%d: expected %q got %q", i, str, ns.S)
 471                 }
 472         }
 473 }
 474
 475 // Another bug from golang-nuts, involving nested interfaces.
 476 type Bug0Outer struct {
 477         Bug0Field interface{}
 478 }
 479
 480 type Bug0Inner struct {
 481         A int
 482 }
 483
 484 func TestNestedInterfaces(t *testing.T) {
 485         var buf bytes.Buffer
 486         e := NewEncoder(&buf)
 487         d := NewDecoder(&buf)
 488         Register(new(Bug0Outer))
 489         Register(new(Bug0Inner))
 490         f := &Bug0Outer{&Bug0Outer{&Bug0Inner{7}}}
 491         var v interface{} = f
 492         err := e.Encode(&v)
 493         if err != nil {
 494                 t.Fatal("Encode:", err)
 495         }
 496         err = d.Decode(&v)
 497         if err != nil {
 498                 t.Fatal("Decode:", err)
 499         }
 500         // Make sure it decoded correctly.
 501         outer1, ok := v.(*Bug0Outer)
 502         if !ok {
 503                 t.Fatalf("v not Bug0Outer: %T", v)
 504         }
 505         outer2, ok := outer1.Bug0Field.(*Bug0Outer)
 506         if !ok {
 507                 t.Fatalf("v.Bug0Field not Bug0Outer: %T", outer1.Bug0Field)
 508         }
 509         inner, ok := outer2.Bug0Field.(*Bug0Inner)
 510         if !ok {
 511                 t.Fatalf("v.Bug0Field.Bug0Field not Bug0Inner: %T", outer2.Bug0Field)
 512         }
 513         if inner.A != 7 {
 514                 t.Fatalf("final value %d; expected %d", inner.A, 7)
 515         }
 516 }