vom/decoder_test.go - release.go.v23 - Git at Google

 // 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_test

 import (
 	"bytes"
 	"fmt"
 	"io"
 	"math/rand"
 	"reflect"
 	"runtime"
 	"strings"
 	"sync"
 	"testing"

 	"v.io/v23/vdl"
 	"v.io/v23/vom"
 	"v.io/v23/vom/testdata/types"
 	"v.io/v23/vom/vomtest"

 	// Import verror to ensure that interface tests result in *verror.E
 	_ "v.io/v23/verror"
 )

 var (
 	rtIface = reflect.TypeOf((*interface{})(nil)).Elem()
 	rtValue = reflect.TypeOf(vdl.Value{})
 )

 func TestDecoder(t *testing.T) {
 	// The decoder tests take a long time, so we run them concurrently.
 	var pending sync.WaitGroup
 	for _, test := range vomtest.AllPass() {
 		pending.Add(1)
 		go func(test vomtest.Entry) {
 			defer pending.Done()
 			testDecoder(t, "[go value]", test, rvPtrValue(test.Value))
 			testDecoder(t, "[go iface]", test, rvPtrIface(test.Value))
 			vv, err := vdl.ValueFromReflect(test.Value)
 			if err != nil {
 				t.Errorf("%s: ValueFromReflect failed: %v", test.Name(), err)
 				return
 			}
 			vvWant := reflect.ValueOf(vv)
 			testDecoder(t, "[new *vdl.Value]", test, vvWant)
 			testDecoderFunc(t, "[zero vdl.Value]", test, vvWant, func() reflect.Value {
 				return reflect.ValueOf(vdl.ZeroValue(vv.Type()))
 			})
 		}(test)
 	}
 	pending.Wait()
 }

 func rvPtrValue(rv reflect.Value) reflect.Value {
 	result := reflect.New(rv.Type())
 	result.Elem().Set(rv)
 	return result
 }

 func rvPtrIface(rv reflect.Value) reflect.Value {
 	result := reflect.New(rtIface)
 	result.Elem().Set(rv)
 	return result
 }

 func testDecoder(t *testing.T, pre string, test vomtest.Entry, rvWant reflect.Value) {
 	testDecoderFunc(t, pre, test, rvWant, func() reflect.Value {
 		return reflect.New(rvWant.Type().Elem())
 	})
 	// TODO(toddw): Add tests that start with a randomly-set value.
 }

 func testDecoderFunc(t *testing.T, pre string, test vomtest.Entry, rvWant reflect.Value, rvNew func() reflect.Value) {
 	readEOF := make([]byte, 1)
 	for _, mode := range vom.AllReadModes {
 		// Test vom.NewDecoder.
 		{
 			name := fmt.Sprintf("%s (%s) %s", pre, mode, test.Name())
 			rvGot := rvNew()
 			reader := mode.TestReader(bytes.NewReader(test.Bytes()))
 			dec := vom.NewDecoder(reader)
 			if err := dec.Decode(rvGot.Interface()); err != nil {
 				t.Errorf("%s: Decode failed: %v", name, err)
 				return
 			}
 			if !vdl.DeepEqualReflect(rvGot, rvWant) {
 				t.Errorf("%s\nGOT  %v\nWANT %v", name, rvGot, rvWant)
 				return
 			}
 			if n, err := reader.Read(readEOF); n != 0 || err != io.EOF {
 				t.Errorf("%s: reader got (%d,%v), want (0,EOF)", name, n, err)
 			}
 		}
 		// Test vom.NewDecoderWithTypeDecoder
 		{
 			name := fmt.Sprintf("%s (%s with TypeDecoder) %s", pre, mode, test.Name())
 			rvGot := rvNew()
 			readerT := mode.TestReader(bytes.NewReader(test.TypeBytes()))
 			decT := vom.NewTypeDecoder(readerT)
 			decT.Start()
 			reader := mode.TestReader(bytes.NewReader(test.ValueBytes()))
 			dec := vom.NewDecoderWithTypeDecoder(reader, decT)
 			err := dec.Decode(rvGot.Interface())
 			decT.Stop()
 			if err != nil {
 				t.Errorf("%s: Decode failed: %v", name, err)
 				return
 			}
 			if !vdl.DeepEqualReflect(rvGot, rvWant) {
 				t.Errorf("%s\nGOT  %v\nWANT %v", name, rvGot, rvWant)
 				return
 			}
 			if n, err := reader.Read(readEOF); n != 0 || err != io.EOF {
 				t.Errorf("%s: reader got (%d,%v), want (0,EOF)", name, n, err)
 			}
 			if n, err := readerT.Read(readEOF); n != 0 || err != io.EOF {
 				t.Errorf("%s: readerT got (%d,%v), want (0,EOF)", name, n, err)
 			}
 		}
 	}
 	// Test single-shot vom.Decode twice, to ensure we test the cache hit case.
 	for i := 0; i < 2; i++ {
 		name := fmt.Sprintf("%s (single-shot %d) %s", pre, i, test.Name())
 		rvGot := rvNew()
 		if err := vom.Decode(test.Bytes(), rvGot.Interface()); err != nil {
 			t.Errorf("%s: Decode failed: %v", name, err)
 			return
 		}
 		if !vdl.DeepEqualReflect(rvGot, rvWant) {
 			t.Errorf("%s\nGOT  %v\nWANT %v", name, rvGot, rvWant)
 			return
 		}
 	}
 }

 // 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 *vom.TypeEncoder
 		typedec *vom.TypeDecoder
 	)
 	if withTypeEncoderDecoder {
 		r, w := newPipe()
 		typeenc = vom.NewTypeEncoder(w)
 		typedec = vom.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 *vom.Encoder
 					decoder *vom.Decoder
 					buf     bytes.Buffer
 				)
 				if withTypeEncoderDecoder {
 					encoder = vom.NewEncoderWithTypeEncoder(&buf, typeenc)
 					decoder = vom.NewDecoderWithTypeDecoder(&buf, typedec)
 				} else {
 					encoder = vom.NewEncoder(&buf)
 					decoder = vom.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
 }

 func hex2Bin(t *testing.T, hex string) []byte {
 	var bin string
 	if _, err := fmt.Sscanf(hex, "%x", &bin); err != nil {
 		t.Fatalf("error converting %q to binary: %v", hex, err)
 	}
 	return []byte(bin)
 }

 // 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 := vom.NewTypeDecoder(tr)
 	typedec.Start()
 	wr := newWaitingReader(strings.NewReader(binversion + binvalue))
 	decoder := vom.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 := vom.NewTypeDecoder(&errorReader{})
 	typedec.Start()
 	decoder := vom.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 := vom.NewDecoder(strings.NewReader("\x81\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 := vom.NewDecoder(strings.NewReader("\x81S*\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 := vom.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 := vom.NewDecoder(strings.NewReader(
 		"\x81W&\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 == nil {
 		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 := vom.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 := vom.Decode(encoded[:x], &f); err == nil {
 			t.Errorf("Decode did not fail with x=%d", x)
 		}
 	}
 }
	// 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_test

	import (
	"bytes"
	"fmt"
	"io"
	"math/rand"
	"reflect"
	"runtime"
	"strings"
	"sync"
	"testing"

	"v.io/v23/vdl"
	"v.io/v23/vom"
	"v.io/v23/vom/testdata/types"
	"v.io/v23/vom/vomtest"

	// Import verror to ensure that interface tests result in *verror.E
	_ "v.io/v23/verror"
	)

	var (
	rtIface = reflect.TypeOf((*interface{})(nil)).Elem()
	rtValue = reflect.TypeOf(vdl.Value{})
	)

	func TestDecoder(t *testing.T) {
	// The decoder tests take a long time, so we run them concurrently.
	var pending sync.WaitGroup
	for _, test := range vomtest.AllPass() {
	pending.Add(1)
	go func(test vomtest.Entry) {
	defer pending.Done()
	testDecoder(t, "[go value]", test, rvPtrValue(test.Value))
	testDecoder(t, "[go iface]", test, rvPtrIface(test.Value))
	vv, err := vdl.ValueFromReflect(test.Value)
	if err != nil {
	t.Errorf("%s: ValueFromReflect failed: %v", test.Name(), err)
	return
	}
	vvWant := reflect.ValueOf(vv)
	testDecoder(t, "[new *vdl.Value]", test, vvWant)
	testDecoderFunc(t, "[zero vdl.Value]", test, vvWant, func() reflect.Value {
	return reflect.ValueOf(vdl.ZeroValue(vv.Type()))
	})
	}(test)
	}
	pending.Wait()
	}

	func rvPtrValue(rv reflect.Value) reflect.Value {
	result := reflect.New(rv.Type())
	result.Elem().Set(rv)
	return result
	}

	func rvPtrIface(rv reflect.Value) reflect.Value {
	result := reflect.New(rtIface)
	result.Elem().Set(rv)
	return result
	}

	func testDecoder(t *testing.T, pre string, test vomtest.Entry, rvWant reflect.Value) {
	testDecoderFunc(t, pre, test, rvWant, func() reflect.Value {
	return reflect.New(rvWant.Type().Elem())
	})
	// TODO(toddw): Add tests that start with a randomly-set value.
	}

	func testDecoderFunc(t *testing.T, pre string, test vomtest.Entry, rvWant reflect.Value, rvNew func() reflect.Value) {
	readEOF := make([]byte, 1)
	for _, mode := range vom.AllReadModes {
	// Test vom.NewDecoder.
	{
	name := fmt.Sprintf("%s (%s) %s", pre, mode, test.Name())
	rvGot := rvNew()
	reader := mode.TestReader(bytes.NewReader(test.Bytes()))
	dec := vom.NewDecoder(reader)
	if err := dec.Decode(rvGot.Interface()); err != nil {
	t.Errorf("%s: Decode failed: %v", name, err)
	return
	}
	if !vdl.DeepEqualReflect(rvGot, rvWant) {
	t.Errorf("%s\nGOT %v\nWANT %v", name, rvGot, rvWant)
	return
	}
	if n, err := reader.Read(readEOF); n != 0 \|\| err != io.EOF {
	t.Errorf("%s: reader got (%d,%v), want (0,EOF)", name, n, err)
	}
	}
	// Test vom.NewDecoderWithTypeDecoder
	{
	name := fmt.Sprintf("%s (%s with TypeDecoder) %s", pre, mode, test.Name())
	rvGot := rvNew()
	readerT := mode.TestReader(bytes.NewReader(test.TypeBytes()))
	decT := vom.NewTypeDecoder(readerT)
	decT.Start()
	reader := mode.TestReader(bytes.NewReader(test.ValueBytes()))
	dec := vom.NewDecoderWithTypeDecoder(reader, decT)
	err := dec.Decode(rvGot.Interface())
	decT.Stop()
	if err != nil {
	t.Errorf("%s: Decode failed: %v", name, err)
	return
	}
	if !vdl.DeepEqualReflect(rvGot, rvWant) {
	t.Errorf("%s\nGOT %v\nWANT %v", name, rvGot, rvWant)
	return
	}
	if n, err := reader.Read(readEOF); n != 0 \|\| err != io.EOF {
	t.Errorf("%s: reader got (%d,%v), want (0,EOF)", name, n, err)
	}
	if n, err := readerT.Read(readEOF); n != 0 \|\| err != io.EOF {
	t.Errorf("%s: readerT got (%d,%v), want (0,EOF)", name, n, err)
	}
	}
	}
	// Test single-shot vom.Decode twice, to ensure we test the cache hit case.
	for i := 0; i < 2; i++ {
	name := fmt.Sprintf("%s (single-shot %d) %s", pre, i, test.Name())
	rvGot := rvNew()
	if err := vom.Decode(test.Bytes(), rvGot.Interface()); err != nil {
	t.Errorf("%s: Decode failed: %v", name, err)
	return
	}
	if !vdl.DeepEqualReflect(rvGot, rvWant) {
	t.Errorf("%s\nGOT %v\nWANT %v", name, rvGot, rvWant)
	return
	}
	}
	}

	// 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 *vom.TypeEncoder
	typedec *vom.TypeDecoder
	)
	if withTypeEncoderDecoder {
	r, w := newPipe()
	typeenc = vom.NewTypeEncoder(w)
	typedec = vom.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 *vom.Encoder
	decoder *vom.Decoder
	buf bytes.Buffer
	)
	if withTypeEncoderDecoder {
	encoder = vom.NewEncoderWithTypeEncoder(&buf, typeenc)
	decoder = vom.NewDecoderWithTypeDecoder(&buf, typedec)
	} else {
	encoder = vom.NewEncoder(&buf)
	decoder = vom.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
	}

	func hex2Bin(t *testing.T, hex string) []byte {
	var bin string
	if _, err := fmt.Sscanf(hex, "%x", &bin); err != nil {
	t.Fatalf("error converting %q to binary: %v", hex, err)
	}
	return []byte(bin)
	}

	// 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 := vom.NewTypeDecoder(tr)
	typedec.Start()
	wr := newWaitingReader(strings.NewReader(binversion + binvalue))
	decoder := vom.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 := vom.NewTypeDecoder(&errorReader{})
	typedec.Start()
	decoder := vom.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 := vom.NewDecoder(strings.NewReader("\x81\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 := vom.NewDecoder(strings.NewReader("\x81S\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 := vom.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 := vom.NewDecoder(strings.NewReader(
	"\x81W&\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 == nil {
	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 := vom.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 := vom.Decode(encoded[:x], &f); err == nil {
	t.Errorf("Decode did not fail with x=%d", x)
	}
	}
	}