| // Copyright 2015 The Vanadium 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 vom |
| |
| import ( |
| "bytes" |
| "fmt" |
| "io" |
| "math/rand" |
| "reflect" |
| "runtime" |
| "strings" |
| "sync" |
| "testing" |
| |
| "v.io/v23/vdl" |
| "v.io/v23/vom/testdata/data80" |
| "v.io/v23/vom/testdata/data81" |
| "v.io/v23/vom/testdata/types" |
| ) |
| |
| func TestDecoder(t *testing.T) { |
| for _, test := range append(data80.Tests, data81.Tests...) { |
| // Decode hex patterns into binary data. |
| binversion, err := binFromHexPat(test.HexVersion) |
| if err != nil { |
| t.Errorf("%s: couldn't convert to binary from hexversion: %q", test.Name, test.HexVersion) |
| continue |
| } |
| bintype, err := binFromHexPat(test.HexType) |
| if err != nil { |
| t.Errorf("%s: couldn't convert to binary from hextype: %q", test.Name, test.HexType) |
| continue |
| } |
| binvalue, err := binFromHexPat(test.HexValue) |
| if err != nil { |
| t.Errorf("%s: couldn't convert to binary from hexvalue: %q", test.Name, test.HexValue) |
| continue |
| } |
| |
| name := test.Name + " [vdl.Value]" |
| testDecodeVDL(t, name, binversion+bintype+binvalue, test.Value) |
| name = test.Name + " [vdl.Value] (with TypeDecoder)" |
| testDecodeVDLWithTypeDecoder(t, name, binversion, bintype, binvalue, test.Value) |
| name = test.Name + " [vdl.Any]" |
| testDecodeVDL(t, name, binversion+bintype+binvalue, vdl.AnyValue(test.Value)) |
| name = test.Name + " [vdl.Any] (with TypeDecoder)" |
| testDecodeVDLWithTypeDecoder(t, name, binversion, bintype, binvalue, vdl.AnyValue(test.Value)) |
| |
| // Convert into Go value for the rest of our tests. |
| goValue, err := toGoValue(test.Value) |
| if err != nil { |
| t.Errorf("%s: %v", test.Name, err) |
| continue |
| } |
| |
| name = test.Name + " [go value]" |
| testDecodeGo(t, name, binversion+bintype+binvalue, reflect.TypeOf(goValue), goValue) |
| name = test.Name + " [go value] (with TypeDecoder)" |
| testDecodeGoWithTypeDecoder(t, name, binversion, bintype, binvalue, reflect.TypeOf(goValue), goValue) |
| |
| name = test.Name + " [go interface]" |
| testDecodeGo(t, name, binversion+bintype+binvalue, reflect.TypeOf((*interface{})(nil)).Elem(), goValue) |
| name = test.Name + " [go interface] (with TypeDecoder)" |
| testDecodeGoWithTypeDecoder(t, name, binversion, bintype, binvalue, reflect.TypeOf((*interface{})(nil)).Elem(), goValue) |
| } |
| } |
| |
| func testDecodeVDL(t *testing.T, name, bin string, value *vdl.Value) { |
| for _, mode := range AllReadModes { |
| head := fmt.Sprintf("%s (%s)", name, mode) |
| decoder := NewDecoder(mode.TestReader(strings.NewReader(bin))) |
| if value == nil { |
| value = vdl.ZeroValue(vdl.AnyType) |
| } |
| got := vdl.ZeroValue(value.Type()) |
| if err := decoder.Decode(got); err != nil { |
| t.Errorf("%s: Decode failed: %v", head, err) |
| return |
| } |
| if want := value; !vdl.EqualValue(got, want) { |
| t.Errorf("%s: Decode mismatch\nGOT %v\nWANT %v", head, got, want) |
| return |
| } |
| } |
| // Test single-shot vom.Decode twice, to ensure we test the cache hit case. |
| testDecodeVDLSingleShot(t, name, bin, value) |
| testDecodeVDLSingleShot(t, name, bin, value) |
| } |
| |
| func testDecodeVDLSingleShot(t *testing.T, name, bin string, value *vdl.Value) { |
| // Test the single-shot vom.Decode. |
| head := fmt.Sprintf("%s (single-shot)", name) |
| got := vdl.ZeroValue(value.Type()) |
| if err := Decode([]byte(bin), got); err != nil { |
| t.Errorf("%s: Decode failed: %v", head, err) |
| return |
| } |
| if want := value; !vdl.EqualValue(got, want) { |
| t.Errorf("%s: Decode mismatch\nGOT %v\nWANT %v", head, got, want) |
| return |
| } |
| } |
| |
| func testDecodeVDLWithTypeDecoder(t *testing.T, name, binversion, bintype, binvalue string, value *vdl.Value) { |
| for _, mode := range AllReadModes { |
| head := fmt.Sprintf("%s (%s)", name, mode) |
| typedec := NewTypeDecoder(mode.TestReader(strings.NewReader(binversion + bintype))) |
| typedec.Start() |
| decoder := NewDecoderWithTypeDecoder(mode.TestReader(strings.NewReader(binversion+binvalue)), typedec) |
| if value == nil { |
| value = vdl.ZeroValue(vdl.AnyType) |
| } |
| got := vdl.ZeroValue(value.Type()) |
| if err := decoder.Decode(got); err != nil { |
| t.Errorf("%s: Decode failed: %v", head, err) |
| return |
| } |
| if want := value; !vdl.EqualValue(got, want) { |
| t.Errorf("%s: Decode mismatch\nGOT %v\nWANT %v", head, got, want) |
| return |
| } |
| typedec.Stop() |
| } |
| } |
| |
| func testDecodeGo(t *testing.T, name, bin string, rt reflect.Type, want interface{}) { |
| for _, mode := range AllReadModes { |
| head := fmt.Sprintf("%s (%s)", name, mode) |
| decoder := NewDecoder(mode.TestReader(strings.NewReader(bin))) |
| var got interface{} |
| if rt != nil { |
| got = reflect.New(rt).Elem().Interface() |
| } |
| if err := decoder.Decode(&got); err != nil { |
| t.Errorf("%s: Decode failed: %v", head, err) |
| return |
| } |
| if !vdl.DeepEqual(got, want) { |
| t.Errorf("%s: Decode mismatch\nGOT %T %+v\nWANT %T %+v", head, got, got, want, want) |
| return |
| } |
| } |
| // Test single-shot vom.Decode twice, to ensure we test the cache hit case. |
| testDecodeGoSingleShot(t, name, bin, rt, want) |
| testDecodeGoSingleShot(t, name, bin, rt, want) |
| } |
| |
| func testDecodeGoSingleShot(t *testing.T, name, bin string, rt reflect.Type, want interface{}) { |
| head := fmt.Sprintf("%s (single-shot)", name) |
| var got interface{} |
| if rt != nil { |
| got = reflect.New(rt).Elem().Interface() |
| } |
| if err := Decode([]byte(bin), &got); err != nil { |
| t.Errorf("%s: Decode failed: %v", head, err) |
| return |
| } |
| if !vdl.DeepEqual(got, want) { |
| t.Errorf("%s: Decode mismatch\nGOT %T %+v\nWANT %T %+v", head, got, got, want, want) |
| return |
| } |
| } |
| |
| func testDecodeGoWithTypeDecoder(t *testing.T, name, binversion, bintype, binvalue string, rt reflect.Type, want interface{}) { |
| for _, mode := range AllReadModes { |
| head := fmt.Sprintf("%s (%s)", name, mode) |
| typedec := NewTypeDecoder(mode.TestReader(strings.NewReader(binversion + bintype))) |
| typedec.Start() |
| decoder := NewDecoderWithTypeDecoder(mode.TestReader(strings.NewReader(binversion+binvalue)), typedec) |
| var got interface{} |
| if rt != nil { |
| got = reflect.New(rt).Elem().Interface() |
| } |
| if err := decoder.Decode(&got); err != nil { |
| t.Errorf("%s: Decode failed: %v", head, err) |
| return |
| } |
| if !vdl.DeepEqual(got, want) { |
| t.Errorf("%s: Decode mismatch\nGOT %T %+v\nWANT %T %+v", head, got, got, want, want) |
| return |
| } |
| typedec.Stop() |
| } |
| } |
| |
| // TestRoundtrip* tests test encoding and then decoding results in various modes. |
| func TestRoundtrip(t *testing.T) { testRoundtrip(t, false, 1) } |
| func TestRoundtripWithTypeDecoder_1(t *testing.T) { testRoundtrip(t, true, 1) } |
| func TestRoundtripWithTypeDecoder_5(t *testing.T) { testRoundtrip(t, true, 5) } |
| func TestRoundtripWithTypeDecoder_10(t *testing.T) { testRoundtrip(t, true, 10) } |
| func TestRoundtripWithTypeDecoder_20(t *testing.T) { testRoundtrip(t, true, 20) } |
| |
| func testRoundtrip(t *testing.T, withTypeEncoderDecoder bool, concurrency int) { |
| mp := runtime.GOMAXPROCS(runtime.NumCPU()) |
| defer runtime.GOMAXPROCS(mp) |
| |
| tests := []struct { |
| In, Want interface{} |
| }{ |
| // Test that encoding nil/empty composites leads to nil. |
| {[]byte(nil), []byte(nil)}, |
| {[]byte{}, []byte(nil)}, |
| {[]int64(nil), []int64(nil)}, |
| {[]int64{}, []int64(nil)}, |
| {map[string]int64(nil), map[string]int64(nil)}, |
| {map[string]int64{}, map[string]int64(nil)}, |
| {struct{}{}, struct{}{}}, |
| {struct{ A []byte }{nil}, struct{ A []byte }{}}, |
| {struct{ A []byte }{[]byte{}}, struct{ A []byte }{}}, |
| {struct{ A []int64 }{nil}, struct{ A []int64 }{}}, |
| {struct{ A []int64 }{[]int64{}}, struct{ A []int64 }{}}, |
| // Test that encoding nil typeobject leads to AnyType. |
| {(*vdl.Type)(nil), vdl.AnyType}, |
| // Test that both encoding and decoding ignore unexported fields. |
| {struct{ a, X, b string }{"a", "XYZ", "b"}, struct{ d, X, e string }{X: "XYZ"}}, |
| { |
| struct { |
| a bool |
| X string |
| b int64 |
| }{true, "XYZ", 123}, |
| struct { |
| a complex64 |
| X string |
| b []byte |
| }{X: "XYZ"}, |
| }, |
| // Test for array encoding/decoding. |
| {[3]byte{1, 2, 3}, [3]byte{1, 2, 3}}, |
| {[3]int64{1, 2, 3}, [3]int64{1, 2, 3}}, |
| // Test for zero value struct/union field encoding/decoding. |
| {struct{ A int64 }{0}, struct{ A int64 }{}}, |
| {struct{ T *vdl.Type }{nil}, struct{ T *vdl.Type }{vdl.AnyType}}, |
| {struct{ M map[uint64]struct{} }{make(map[uint64]struct{})}, struct{ M map[uint64]struct{} }{}}, |
| {struct{ M map[uint64]string }{make(map[uint64]string)}, struct{ M map[uint64]string }{}}, |
| {struct{ N struct{ A int64 } }{struct{ A int64 }{0}}, struct{ N struct{ A int64 } }{}}, |
| {struct{ N *types.NStruct }{&types.NStruct{A: false, B: "", C: 0}}, struct{ N *types.NStruct }{&types.NStruct{}}}, |
| {struct{ N *types.NStruct }{nil}, struct{ N *types.NStruct }{}}, |
| {types.NUnion(types.NUnionA{Value: false}), types.NUnion(types.NUnionA{})}, |
| {types.RecA{}, types.RecA(nil)}, |
| {types.RecStruct{}, types.RecStruct{}}, |
| // Test for verifying correctness when encoding/decoding shared types concurrently. |
| {types.MStruct{}, types.MStruct{E: vdl.AnyType, F: vdl.AnyValue(nil)}}, |
| {types.NStruct{}, types.NStruct{}}, |
| {types.XyzStruct{}, types.XyzStruct{}}, |
| {types.YzStruct{}, types.YzStruct{}}, |
| {types.MBool(false), types.MBool(false)}, |
| {types.NString(""), types.NString("")}, |
| {vdl.ValueOf(uint16(5)), vdl.ValueOf(uint16(5))}, |
| {vdl.ValueOf([]interface{}{uint16(5)}).Index(0), vdl.ValueOf(uint16(5))}, |
| } |
| |
| var ( |
| typeenc *TypeEncoder |
| typedec *TypeDecoder |
| ) |
| if withTypeEncoderDecoder { |
| r, w := newPipe() |
| typeenc = NewTypeEncoder(w) |
| typedec = NewTypeDecoder(r) |
| typedec.Start() |
| defer typedec.Stop() |
| } |
| |
| var wg sync.WaitGroup |
| for n := 0; n < concurrency; n++ { |
| wg.Add(1) |
| go func(n int) { |
| defer wg.Done() |
| for _, n := range rand.Perm(len(tests) * 10) { |
| test := tests[n%len(tests)] |
| name := fmt.Sprintf("[%d]:%+v,%+v", n, test.In, test.Want) |
| |
| var ( |
| encoder *Encoder |
| decoder *Decoder |
| buf bytes.Buffer |
| ) |
| if withTypeEncoderDecoder { |
| encoder = NewEncoderWithTypeEncoder(&buf, typeenc) |
| decoder = NewDecoderWithTypeDecoder(&buf, typedec) |
| } else { |
| encoder = NewEncoder(&buf) |
| decoder = NewDecoder(&buf) |
| } |
| |
| if err := encoder.Encode(test.In); err != nil { |
| t.Errorf("%s: Encode(%+v) failed: %v", name, test.In, err) |
| return |
| } |
| rv := reflect.New(reflect.TypeOf(test.Want)) |
| if err := decoder.Decode(rv.Interface()); err != nil { |
| t.Errorf("%s: Decode failed: %v", name, err) |
| return |
| } |
| if got := rv.Elem().Interface(); !vdl.DeepEqual(got, test.Want) { |
| t.Errorf("%s: Decode mismatch\nGOT %T %+v\nWANT %T %+v", name, got, got, test.Want, test.Want) |
| return |
| } |
| } |
| }(n) |
| } |
| wg.Wait() |
| } |
| |
| // waitingReader is a reader wrapper that waits until it is signalled before |
| // beginning to read. |
| type waitingReader struct { |
| lock sync.Mutex |
| cond *sync.Cond |
| activated bool |
| r io.Reader |
| } |
| |
| func newWaitingReader(r io.Reader) *waitingReader { |
| wr := &waitingReader{ |
| r: r, |
| } |
| wr.cond = sync.NewCond(&wr.lock) |
| return wr |
| } |
| |
| func (wr *waitingReader) Read(p []byte) (int, error) { |
| wr.lock.Lock() |
| for !wr.activated { |
| wr.cond.Wait() |
| } |
| wr.lock.Unlock() |
| return wr.r.Read(p) |
| } |
| |
| func (wr *waitingReader) Activate() { |
| wr.lock.Lock() |
| wr.activated = true |
| wr.cond.Broadcast() |
| wr.lock.Unlock() |
| } |
| |
| type extractErrReader struct { |
| lock sync.Mutex |
| cond *sync.Cond |
| err error |
| r io.Reader |
| } |
| |
| func newExtractErrReader(r io.Reader) *extractErrReader { |
| er := &extractErrReader{ |
| r: r, |
| } |
| er.cond = sync.NewCond(&er.lock) |
| return er |
| } |
| |
| func (er *extractErrReader) Read(p []byte) (int, error) { |
| n, err := er.r.Read(p) |
| if err != nil { |
| er.lock.Lock() |
| er.err = err |
| er.cond.Broadcast() |
| er.lock.Unlock() |
| } |
| return n, err |
| } |
| |
| func (er *extractErrReader) WaitForError() error { |
| er.lock.Lock() |
| for er.err == nil { |
| er.cond.Wait() |
| } |
| err := er.err |
| er.lock.Unlock() |
| return err |
| } |
| |
| // Test that no EOF is returned from Decode() if the type stream finished before the value stream. |
| func TestTypeStreamEndsFirst(t *testing.T) { |
| hexversion := "81" |
| hextype := "5133060025762e696f2f7632332f766f6d2f74657374646174612f74797065732e537472756374416e7901010003416e79010fe1e1533b060023762e696f2f7632332f766f6d2f74657374646174612f74797065732e4e53747275637401030001410101e10001420103e10001430109e1e1" |
| hexvalue := "52012a0103070000000001e1e1" |
| binversion := string(hex2Bin(t, hexversion)) |
| bintype := string(hex2Bin(t, hextype)) |
| binvalue := string(hex2Bin(t, hexvalue)) |
| // Ensure EOF isn't returned if the type decode stream ends first |
| tr := newExtractErrReader(strings.NewReader(binversion + bintype)) |
| typedec := NewTypeDecoder(tr) |
| typedec.Start() |
| wr := newWaitingReader(strings.NewReader(binversion + binvalue)) |
| decoder := NewDecoderWithTypeDecoder(wr, typedec) |
| var v interface{} |
| go func() { |
| if tr.WaitForError() == nil { |
| t.Fatalf("expected EOF after reaching end of type stream, but didn't occur") |
| } |
| wr.Activate() |
| }() |
| if err := decoder.Decode(&v); err != nil { |
| t.Errorf("expected no error in decode, but got: %v", err) |
| } |
| } |
| |
| // Return an error on all reads. |
| type errorReader struct { |
| } |
| |
| func (er *errorReader) Read(p []byte) (int, error) { |
| return 0, fmt.Errorf("errorReader error\n") |
| } |
| |
| // Test that non-EOF errors on the value stream are returned from Decode() calls. |
| func TestReceiveTypeStreamError(t *testing.T) { |
| hexversion := "80" |
| hexvalue := "5206002a000001e1" |
| binversion := string(hex2Bin(t, hexversion)) |
| binvalue := string(hex2Bin(t, hexvalue)) |
| // Ensure EOF isn't returned if the type decode stream ends first |
| typedec := NewTypeDecoder(&errorReader{}) |
| typedec.Start() |
| decoder := NewDecoderWithTypeDecoder(strings.NewReader(binversion+binvalue), typedec) |
| var v interface{} |
| if err := decoder.Decode(&v); err == nil { |
| t.Errorf("expected error in decode, but got none") |
| } |
| } |
| |
| // Test that using the type decoder incorrectly does not result |
| // in a deadlock. |
| func TestFuzzTypeDecodeDeadlock(t *testing.T) { |
| var v interface{} |
| d := NewDecoder(strings.NewReader("\x80\x30")) |
| // Before the fix, this line caused a deadlock and panic. |
| d.Decode(&v) |
| return |
| } |
| |
| // Tests that an input go-fuzz found will no longer cause a |
| // panic over in package vdl. |
| func TestFuzzVdlPanic(t *testing.T) { |
| var v interface{} |
| d := NewDecoder(strings.NewReader("\x80S*\x00\x00$000000000000000000000000000000000000\x01*\xe1U(\x05\x00 00000000000000000000000000000000\x01*\x02+\xe1")) |
| // Before this fix this line caused a panic. |
| d.Decode(&v) |
| return |
| } |
| |
| // In concurrent modes, one goroutine may try to read vom types before they are |
| // actually sent by other goroutine. We use a simple buffered pipe to provide |
| // blocking read since bytes.Buffer will return EOF in this case. |
| type pipe struct { |
| b bytes.Buffer |
| m sync.Mutex |
| c sync.Cond |
| cancelled bool |
| } |
| |
| func newPipe() (io.ReadCloser, io.WriteCloser) { |
| p := &pipe{} |
| p.c.L = &p.m |
| return p, p |
| } |
| |
| func (r *pipe) Read(p []byte) (n int, err error) { |
| r.m.Lock() |
| defer r.m.Unlock() |
| for r.b.Len() == 0 || r.cancelled { |
| r.c.Wait() |
| } |
| return r.b.Read(p) |
| } |
| |
| func (p *pipe) Close() error { |
| p.m.Lock() |
| p.cancelled = true |
| p.c.Broadcast() |
| p.m.Unlock() |
| return nil |
| } |
| |
| func (w *pipe) Write(p []byte) (n int, err error) { |
| w.m.Lock() |
| defer w.m.Unlock() |
| defer w.c.Signal() |
| return w.b.Write(p) |
| } |
| |
| // Test that input found by go-fuzz cannot cause a stack overflow. |
| func TestFuzzDecodeOverflow(t *testing.T) { |
| var v interface{} |
| d := NewDecoder(strings.NewReader("\x81\x51\x04\x03\x01\x29\xe1")) |
| |
| // Before the fix, this line caused a stack overflow. After the fix, we |
| // expect an error. |
| if err := d.Decode(&v); err == nil { |
| t.Fatal("unexpected success") |
| } |
| } |
| |
| // Test that input discovered by go-fuzz does not result in a hang anymore. |
| func TestFuzzTypeDecodeHang(t *testing.T) { |
| var v interface{} |
| d := NewDecoder(strings.NewReader( |
| "\x80W&\x03\x00 v.io/v23/vom/t" + |
| "estdata/types.Rec4\x01)" + |
| "\xe1U&\x03\x00 v.io/v23/vom/t" + |
| "estdata/types.Rec3\x01," + |
| "\xe1S&\x00\x00 v.io/v23/v\x04\x00/t" + |
| "estdata/types.Rec2\x01*" + |
| "\xe1Q&\x00\x00 v.io/v23/vom/t" + |
| "estdataPtypesIRec1\x01*" + |
| "\xe1")) |
| |
| // Before the fix, this line caused a hang. With the fix, it should |
| // give an error. |
| err := d.Decode(&v) |
| if err != io.EOF { |
| t.Fatal("unexpected success") |
| } |
| } |
| |
| // Test that truncated input is handled gracefully. |
| func TestDecodeTruncatedInput(t *testing.T) { |
| type bar struct { |
| I []int64 |
| } |
| type foo struct { |
| S string |
| I int32 |
| F float64 |
| X []byte |
| B bar |
| } |
| encoded, err := Encode(foo{"hello", 42, 3.14159265359, []byte{1, 2, 3, 4, 5, 6}, bar{[]int64{0}}}) |
| if err != nil { |
| t.Fatalf("Encode failed: %v", err) |
| } |
| for x := 0; x < len(encoded)-1; x++ { |
| var f interface{} |
| if err := Decode(encoded[:x], &f); err == nil { |
| t.Errorf("Encode did not fail with x=%d", x) |
| } |
| } |
| } |
