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

import (
	"fmt"
	"reflect"
	"sync"
	"testing"
	"unsafe"
)

// Tests of TypeFromReflect success.
type rtTest struct {
	rt reflect.Type
	t  *Type
}

// rtKeyTests contains types that may be used as map keys.
var rtKeyTests = []rtTest{
	// Unnamed scalars
	{reflect.TypeOf(bool(false)), BoolType},
	{reflect.TypeOf(byte(0)), ByteType},
	{reflect.TypeOf(uint16(0)), Uint16Type},
	{reflect.TypeOf(uint32(0)), Uint32Type},
	{reflect.TypeOf(uint64(0)), Uint64Type},
	{reflect.TypeOf(uint(0)), testUintType()},
	{reflect.TypeOf(uintptr(0)), testUintptrType()},
	{reflect.TypeOf(int8(0)), Int8Type},
	{reflect.TypeOf(int16(0)), Int16Type},
	{reflect.TypeOf(int32(0)), Int32Type},
	{reflect.TypeOf(int64(0)), Int64Type},
	{reflect.TypeOf(int(0)), testIntType()},
	{reflect.TypeOf(float32(0)), Float32Type},
	{reflect.TypeOf(float64(0)), Float64Type},
	{reflect.TypeOf(string("")), StringType},
	// Named scalars
	{reflect.TypeOf(NBool(false)), NameN("Bool", BoolType)},
	{reflect.TypeOf(NByte(0)), NameN("Byte", ByteType)},
	{reflect.TypeOf(NUint16(0)), NameN("Uint16", Uint16Type)},
	{reflect.TypeOf(NUint32(0)), NameN("Uint32", Uint32Type)},
	{reflect.TypeOf(NUint64(0)), NameN("Uint64", Uint64Type)},
	{reflect.TypeOf(NUint(0)), NameN("Uint", testUintType())},
	{reflect.TypeOf(NUintptr(0)), NameN("Uintptr", testUintptrType())},
	{reflect.TypeOf(NInt8(0)), NameN("Int8", Int8Type)},
	{reflect.TypeOf(NInt16(0)), NameN("Int16", Int16Type)},
	{reflect.TypeOf(NInt32(0)), NameN("Int32", Int32Type)},
	{reflect.TypeOf(NInt64(0)), NameN("Int64", Int64Type)},
	{reflect.TypeOf(NInt(0)), NameN("Int", testIntType())},
	{reflect.TypeOf(NFloat32(0)), NameN("Float32", Float32Type)},
	{reflect.TypeOf(NFloat64(0)), NameN("Float64", Float64Type)},
	{reflect.TypeOf(NString("")), NameN("String", StringType)},
	// Unnamed arrays
	{reflect.TypeOf([3]bool{}), ArrayType(3, BoolType)},
	{reflect.TypeOf([3]byte{}), ArrayType(3, ByteType)},
	{reflect.TypeOf([3]uint16{}), ArrayType(3, Uint16Type)},
	{reflect.TypeOf([3]uint32{}), ArrayType(3, Uint32Type)},
	{reflect.TypeOf([3]uint64{}), ArrayType(3, Uint64Type)},
	{reflect.TypeOf([3]uint{}), ArrayType(3, testUintType())},
	{reflect.TypeOf([3]uintptr{}), ArrayType(3, testUintptrType())},
	{reflect.TypeOf([3]int8{}), ArrayType(3, Int8Type)},
	{reflect.TypeOf([3]int16{}), ArrayType(3, Int16Type)},
	{reflect.TypeOf([3]int32{}), ArrayType(3, Int32Type)},
	{reflect.TypeOf([3]int64{}), ArrayType(3, Int64Type)},
	{reflect.TypeOf([3]int{}), ArrayType(3, testIntType())},
	{reflect.TypeOf([3]float32{}), ArrayType(3, Float32Type)},
	{reflect.TypeOf([3]float64{}), ArrayType(3, Float64Type)},
	{reflect.TypeOf([3]string{}), ArrayType(3, StringType)},
	// Named arrays
	{reflect.TypeOf(NArray3Bool{}), NameNArray("Bool", BoolType)},
	{reflect.TypeOf(NArray3Byte{}), NameNArray("Byte", ByteType)},
	{reflect.TypeOf(NArray3Uint16{}), NameNArray("Uint16", Uint16Type)},
	{reflect.TypeOf(NArray3Uint32{}), NameNArray("Uint32", Uint32Type)},
	{reflect.TypeOf(NArray3Uint64{}), NameNArray("Uint64", Uint64Type)},
	{reflect.TypeOf(NArray3Uint{}), NameNArray("Uint", testUintType())},
	{reflect.TypeOf(NArray3Uintptr{}), NameNArray("Uintptr", testUintptrType())},
	{reflect.TypeOf(NArray3Int8{}), NameNArray("Int8", Int8Type)},
	{reflect.TypeOf(NArray3Int16{}), NameNArray("Int16", Int16Type)},
	{reflect.TypeOf(NArray3Int32{}), NameNArray("Int32", Int32Type)},
	{reflect.TypeOf(NArray3Int64{}), NameNArray("Int64", Int64Type)},
	{reflect.TypeOf(NArray3Int{}), NameNArray("Int", testIntType())},
	{reflect.TypeOf(NArray3Float32{}), NameNArray("Float32", Float32Type)},
	{reflect.TypeOf(NArray3Float64{}), NameNArray("Float64", Float64Type)},
	{reflect.TypeOf(NArray3String{}), NameNArray("String", StringType)},
	// Unnamed structs
	{reflect.TypeOf(struct{ X bool }{}), StructType(Field{"X", BoolType})},
	{reflect.TypeOf(struct{ X byte }{}), StructType(Field{"X", ByteType})},
	{reflect.TypeOf(struct{ X uint16 }{}), StructType(Field{"X", Uint16Type})},
	{reflect.TypeOf(struct{ X uint32 }{}), StructType(Field{"X", Uint32Type})},
	{reflect.TypeOf(struct{ X uint64 }{}), StructType(Field{"X", Uint64Type})},
	{reflect.TypeOf(struct{ X uint }{}), StructType(Field{"X", testUintType()})},
	{reflect.TypeOf(struct{ X uintptr }{}), StructType(Field{"X", testUintptrType()})},
	{reflect.TypeOf(struct{ X int8 }{}), StructType(Field{"X", Int8Type})},
	{reflect.TypeOf(struct{ X int16 }{}), StructType(Field{"X", Int16Type})},
	{reflect.TypeOf(struct{ X int32 }{}), StructType(Field{"X", Int32Type})},
	{reflect.TypeOf(struct{ X int64 }{}), StructType(Field{"X", Int64Type})},
	{reflect.TypeOf(struct{ X int }{}), StructType(Field{"X", testIntType()})},
	{reflect.TypeOf(struct{ X float32 }{}), StructType(Field{"X", Float32Type})},
	{reflect.TypeOf(struct{ X float64 }{}), StructType(Field{"X", Float64Type})},
	{reflect.TypeOf(struct{ X string }{}), StructType(Field{"X", StringType})},
	// Named structs
	{reflect.TypeOf(NStructBool{}), NameNStruct("Bool", BoolType)},
	{reflect.TypeOf(NStructByte{}), NameNStruct("Byte", ByteType)},
	{reflect.TypeOf(NStructUint16{}), NameNStruct("Uint16", Uint16Type)},
	{reflect.TypeOf(NStructUint32{}), NameNStruct("Uint32", Uint32Type)},
	{reflect.TypeOf(NStructUint64{}), NameNStruct("Uint64", Uint64Type)},
	{reflect.TypeOf(NStructUint{}), NameNStruct("Uint", testUintType())},
	{reflect.TypeOf(NStructUintptr{}), NameNStruct("Uintptr", testUintptrType())},
	{reflect.TypeOf(NStructInt8{}), NameNStruct("Int8", Int8Type)},
	{reflect.TypeOf(NStructInt16{}), NameNStruct("Int16", Int16Type)},
	{reflect.TypeOf(NStructInt32{}), NameNStruct("Int32", Int32Type)},
	{reflect.TypeOf(NStructInt64{}), NameNStruct("Int64", Int64Type)},
	{reflect.TypeOf(NStructInt{}), NameNStruct("Int", testIntType())},
	{reflect.TypeOf(NStructFloat32{}), NameNStruct("Float32", Float32Type)},
	{reflect.TypeOf(NStructFloat64{}), NameNStruct("Float64", Float64Type)},
	{reflect.TypeOf(NStructString{}), NameNStruct("String", StringType)},
	// Special-case types
	{reflect.TypeOf(NEnum(0)), NameN("Enum", EnumType("A", "B", "C", "ABC"))},
	{reflect.TypeOf((*NUnionABC)(nil)).Elem(), UnionABCTypeN},
	{reflect.TypeOf(NUnionABCA{}), UnionABCTypeN},
	{reflect.TypeOf(NUnionABCB{}), UnionABCTypeN},
	{reflect.TypeOf(NUnionABCC{}), UnionABCTypeN},
	{reflect.TypeOf(NNative(0)), WireTypeN},
	{reflect.TypeOf(NWire{}), WireTypeN},
}

var (
	nonPtrError error = NonPtrError{}
	ptrError    error = &PtrError{}
)

// rtNonKeyTests contains types that may not be used as map keys.
var rtNonKeyTests = []rtTest{
	// Unnamed scalars
	{reflect.Type(nil), AnyType},
	{reflect.TypeOf((*interface{})(nil)), AnyType},
	{reflect.TypeOf((*interface{})(nil)).Elem(), AnyType},
	{reflect.TypeOf((*error)(nil)), ErrorType},
	{reflect.TypeOf((*error)(nil)).Elem(), ErrorType},
	{reflect.TypeOf(&nonPtrError), ErrorType},
	{reflect.TypeOf(&ptrError), ErrorType},
	{reflect.TypeOf((*Type)(nil)), TypeObjectType},
	// Named scalars (we cannot detect the error type if it is named)
	{reflect.TypeOf((*NInterface)(nil)), AnyType},
	{reflect.TypeOf((*NInterface)(nil)).Elem(), AnyType},
	// Unnamed arrays
	{reflect.TypeOf([3]interface{}{}), ArrayType(3, AnyType)},
	{reflect.TypeOf([3]error{}), ArrayType(3, ErrorType)},
	{reflect.TypeOf([3]*Type{}), ArrayType(3, TypeObjectType)},
	// Named arrays
	{reflect.TypeOf(NArray3Interface{}), NameNArray("Interface", AnyType)},
	{reflect.TypeOf(NArray3TypeObject{}), NameNArray("TypeObject", TypeObjectType)},
	// Unnamed structs
	{reflect.TypeOf(struct{ X interface{} }{}), StructType(Field{"X", AnyType})},
	{reflect.TypeOf(struct{ X error }{}), StructType(Field{"X", ErrorType})},
	{reflect.TypeOf(struct{ X *Type }{}), StructType(Field{"X", TypeObjectType})},
	// Named structs
	{reflect.TypeOf(NStructInterface{}), NameNStruct("Interface", AnyType)},
	{reflect.TypeOf(NStructTypeObject{}), NameNStruct("TypeObject", TypeObjectType)},
	// Unnamed slices
	{reflect.TypeOf([]interface{}{}), ListType(AnyType)},
	{reflect.TypeOf([]error{}), ListType(ErrorType)},
	{reflect.TypeOf([]*Type{}), ListType(TypeObjectType)},
	{reflect.TypeOf([]bool{}), ListType(BoolType)},
	{reflect.TypeOf([]byte{}), ListType(ByteType)},
	{reflect.TypeOf([]uint16{}), ListType(Uint16Type)},
	{reflect.TypeOf([]uint32{}), ListType(Uint32Type)},
	{reflect.TypeOf([]uint64{}), ListType(Uint64Type)},
	{reflect.TypeOf([]uint{}), ListType(testUintType())},
	{reflect.TypeOf([]uintptr{}), ListType(testUintptrType())},
	{reflect.TypeOf([]int8{}), ListType(Int8Type)},
	{reflect.TypeOf([]int16{}), ListType(Int16Type)},
	{reflect.TypeOf([]int32{}), ListType(Int32Type)},
	{reflect.TypeOf([]int64{}), ListType(Int64Type)},
	{reflect.TypeOf([]int{}), ListType(testIntType())},
	{reflect.TypeOf([]float32{}), ListType(Float32Type)},
	{reflect.TypeOf([]float64{}), ListType(Float64Type)},
	{reflect.TypeOf([]string{}), ListType(StringType)},
	// Named slices
	{reflect.TypeOf(NSliceInterface{}), NameNSlice("Interface", AnyType)},
	{reflect.TypeOf(NSliceTypeObject{}), NameNSlice("TypeObject", TypeObjectType)},
	{reflect.TypeOf(NSliceBool{}), NameNSlice("Bool", BoolType)},
	{reflect.TypeOf(NSliceByte{}), NameNSlice("Byte", ByteType)},
	{reflect.TypeOf(NSliceUint16{}), NameNSlice("Uint16", Uint16Type)},
	{reflect.TypeOf(NSliceUint32{}), NameNSlice("Uint32", Uint32Type)},
	{reflect.TypeOf(NSliceUint64{}), NameNSlice("Uint64", Uint64Type)},
	{reflect.TypeOf(NSliceUint{}), NameNSlice("Uint", testUintType())},
	{reflect.TypeOf(NSliceUintptr{}), NameNSlice("Uintptr", testUintptrType())},
	{reflect.TypeOf(NSliceInt8{}), NameNSlice("Int8", Int8Type)},
	{reflect.TypeOf(NSliceInt16{}), NameNSlice("Int16", Int16Type)},
	{reflect.TypeOf(NSliceInt32{}), NameNSlice("Int32", Int32Type)},
	{reflect.TypeOf(NSliceInt64{}), NameNSlice("Int64", Int64Type)},
	{reflect.TypeOf(NSliceInt{}), NameNSlice("Int", testIntType())},
	{reflect.TypeOf(NSliceFloat32{}), NameNSlice("Float32", Float32Type)},
	{reflect.TypeOf(NSliceFloat64{}), NameNSlice("Float64", Float64Type)},
	{reflect.TypeOf(NSliceString{}), NameNSlice("String", StringType)},
	// Unnamed sets
	{reflect.TypeOf(map[bool]struct{}{}), rtSet(BoolType)},
	{reflect.TypeOf(map[byte]struct{}{}), rtSet(ByteType)},
	{reflect.TypeOf(map[uint16]struct{}{}), rtSet(Uint16Type)},
	{reflect.TypeOf(map[uint32]struct{}{}), rtSet(Uint32Type)},
	{reflect.TypeOf(map[uint64]struct{}{}), rtSet(Uint64Type)},
	{reflect.TypeOf(map[uint]struct{}{}), rtSet(testUintType())},
	{reflect.TypeOf(map[uintptr]struct{}{}), rtSet(testUintptrType())},
	{reflect.TypeOf(map[int8]struct{}{}), rtSet(Int8Type)},
	{reflect.TypeOf(map[int16]struct{}{}), rtSet(Int16Type)},
	{reflect.TypeOf(map[int32]struct{}{}), rtSet(Int32Type)},
	{reflect.TypeOf(map[int64]struct{}{}), rtSet(Int64Type)},
	{reflect.TypeOf(map[int]struct{}{}), rtSet(testIntType())},
	{reflect.TypeOf(map[float32]struct{}{}), rtSet(Float32Type)},
	{reflect.TypeOf(map[float64]struct{}{}), rtSet(Float64Type)},
	{reflect.TypeOf(map[string]struct{}{}), rtSet(StringType)},
	// Named sets
	{reflect.TypeOf(NSetBool{}), NameNSet("Bool", BoolType)},
	{reflect.TypeOf(NSetByte{}), NameNSet("Byte", ByteType)},
	{reflect.TypeOf(NSetUint16{}), NameNSet("Uint16", Uint16Type)},
	{reflect.TypeOf(NSetUint32{}), NameNSet("Uint32", Uint32Type)},
	{reflect.TypeOf(NSetUint64{}), NameNSet("Uint64", Uint64Type)},
	{reflect.TypeOf(NSetUint{}), NameNSet("Uint", testUintType())},
	{reflect.TypeOf(NSetUintptr{}), NameNSet("Uintptr", testUintptrType())},
	{reflect.TypeOf(NSetInt8{}), NameNSet("Int8", Int8Type)},
	{reflect.TypeOf(NSetInt16{}), NameNSet("Int16", Int16Type)},
	{reflect.TypeOf(NSetInt32{}), NameNSet("Int32", Int32Type)},
	{reflect.TypeOf(NSetInt64{}), NameNSet("Int64", Int64Type)},
	{reflect.TypeOf(NSetInt{}), NameNSet("Int", testIntType())},
	{reflect.TypeOf(NSetFloat32{}), NameNSet("Float32", Float32Type)},
	{reflect.TypeOf(NSetFloat64{}), NameNSet("Float64", Float64Type)},
	{reflect.TypeOf(NSetString{}), NameNSet("String", StringType)},
	// Unnamed maps
	{reflect.TypeOf(map[bool]bool{}), rtMap(BoolType)},
	{reflect.TypeOf(map[byte]byte{}), rtMap(ByteType)},
	{reflect.TypeOf(map[uint16]uint16{}), rtMap(Uint16Type)},
	{reflect.TypeOf(map[uint32]uint32{}), rtMap(Uint32Type)},
	{reflect.TypeOf(map[uint64]uint64{}), rtMap(Uint64Type)},
	{reflect.TypeOf(map[uint]uint{}), rtMap(testUintType())},
	{reflect.TypeOf(map[uintptr]uintptr{}), rtMap(testUintptrType())},
	{reflect.TypeOf(map[int8]int8{}), rtMap(Int8Type)},
	{reflect.TypeOf(map[int16]int16{}), rtMap(Int16Type)},
	{reflect.TypeOf(map[int32]int32{}), rtMap(Int32Type)},
	{reflect.TypeOf(map[int64]int64{}), rtMap(Int64Type)},
	{reflect.TypeOf(map[int]int{}), rtMap(testIntType())},
	{reflect.TypeOf(map[float32]float32{}), rtMap(Float32Type)},
	{reflect.TypeOf(map[float64]float64{}), rtMap(Float64Type)},
	{reflect.TypeOf(map[string]string{}), rtMap(StringType)},
	// Named maps
	{reflect.TypeOf(NMapBool{}), NameNMap("Bool", BoolType)},
	{reflect.TypeOf(NMapByte{}), NameNMap("Byte", ByteType)},
	{reflect.TypeOf(NMapUint16{}), NameNMap("Uint16", Uint16Type)},
	{reflect.TypeOf(NMapUint32{}), NameNMap("Uint32", Uint32Type)},
	{reflect.TypeOf(NMapUint64{}), NameNMap("Uint64", Uint64Type)},
	{reflect.TypeOf(NMapUint{}), NameNMap("Uint", testUintType())},
	{reflect.TypeOf(NMapUintptr{}), NameNMap("Uintptr", testUintptrType())},
	{reflect.TypeOf(NMapInt8{}), NameNMap("Int8", Int8Type)},
	{reflect.TypeOf(NMapInt16{}), NameNMap("Int16", Int16Type)},
	{reflect.TypeOf(NMapInt32{}), NameNMap("Int32", Int32Type)},
	{reflect.TypeOf(NMapInt64{}), NameNMap("Int64", Int64Type)},
	{reflect.TypeOf(NMapInt{}), NameNMap("Int", testIntType())},
	{reflect.TypeOf(NMapFloat32{}), NameNMap("Float32", Float32Type)},
	{reflect.TypeOf(NMapFloat64{}), NameNMap("Float64", Float64Type)},
	{reflect.TypeOf(NMapString{}), NameNMap("String", StringType)},
	// Recursive types
	{reflect.TypeOf(NRecurseSelf{}), RecurseSelfType()},
	{reflect.TypeOf(NRecurseA{}), RecurseAType()},
	{reflect.TypeOf(NRecurseB{}), RecurseBType()},
}

func testUintType() *Type {
	switch bitlen := 8 * unsafe.Sizeof(uint(0)); bitlen {
	case 32:
		return Uint32Type
	case 64:
		return Uint64Type
	default:
		panic(fmt.Errorf("testUintType unhandled bitlen %d", bitlen))
	}
}

func testUintptrType() *Type {
	switch bitlen := 8 * unsafe.Sizeof(uintptr(0)); bitlen {
	case 32:
		return Uint32Type
	case 64:
		return Uint64Type
	default:
		panic(fmt.Errorf("testUintptrType unhandled bitlen %d", bitlen))
	}
}

func testIntType() *Type {
	switch bitlen := 8 * unsafe.Sizeof(int(0)); bitlen {
	case 32:
		return Int32Type
	case 64:
		return Int64Type
	default:
		panic(fmt.Errorf("testIntType unhandled bitlen %d", bitlen))
	}
}

func allTests() []rtTest {
	// Start with all keys and non keys
	tests := make([]rtTest, len(rtKeyTests)+len(rtNonKeyTests))
	n := copy(tests, rtKeyTests)
	copy(tests[n:], rtNonKeyTests)
	// Add all types we can generate via reflect.
	for _, test := range rtKeyTests {
		if test.t.CanBeOptional() {
			tests = append(tests, rtTest{reflect.PtrTo(test.rt), OptionalType(test.t)})
		} else {
			tests = append(tests, rtTest{reflect.PtrTo(test.rt), test.t})
		}
		tests = append(tests, rtTest{reflect.SliceOf(test.rt), ListType(test.t)})
		tests = append(tests, rtTest{reflect.MapOf(test.rt, test.rt), MapType(test.t, test.t)})
	}
	// Now generate types from everything we have so far, for more complicated subtypes.
	for _, test := range tests {
		if test.rt == nil {
			continue
		}
		if test.t.CanBeOptional() {
			tests = append(tests, rtTest{reflect.PtrTo(test.rt), OptionalType(test.t)})
		} else {
			tests = append(tests, rtTest{reflect.PtrTo(test.rt), test.t})
		}
		tests = append(tests, rtTest{reflect.SliceOf(test.rt), ListType(test.t)})
		for _, key := range rtKeyTests {
			// Only generate maps with valid keys.
			tests = append(tests, rtTest{reflect.MapOf(key.rt, reflect.SliceOf(test.rt)), MapType(key.t, ListType(test.t))})
		}
	}
	return tests
}

func TestTypeFromReflect(t *testing.T) {
	// Make sure we can create all types without the cache.
	rtCacheEnabled = false
	testTypeFromReflect(t, "no cache")
	// Enable the cache, and make multiple goroutines update the same types
	// concurrently.  This should expose locking issues in the cache.
	rtCacheEnabled = true
	var done sync.WaitGroup
	for i := 0; i < 3; i++ {
		done.Add(1)
		go func(i int) {
			testTypeFromReflect(t, fmt.Sprintf("cache%d", i))
			done.Done()
		}(i)
	}
	done.Wait()
	// Final test with all types already cached.
	testTypeFromReflect(t, "all cached")
}

func testTypeFromReflect(t *testing.T, prefix string) {
	for _, test := range allTests() {
		got, err := TypeFromReflect(test.rt)
		ExpectErr(t, err, "", "%s TypeFromReflect(%v)", prefix, test.rt)
		if want := test.t; got != want {
			t.Errorf("%s TypeFromReflect(%v) got type %v, want %v", prefix, test.rt, got, want)
		}
		// Make sure that the type is automatically registered, if it is named.
		if test.rt != nil && test.t.Name() != "" {
			if rt := TypeToReflect(test.t); rt == nil {
				t.Errorf("%s TypeFromReflect(%v) got TypeToReflect nil, want non-nil", prefix, test.rt)
			}
		}
	}
}

var rtErrorTests = []rtErrorTest{
	{reflect.TypeOf(make(chan int64)), `type "chan int64" not supported`},
	{reflect.TypeOf(func() {}), `type "func()" not supported`},
	{reflect.TypeOf(unsafe.Pointer(nil)), `type "unsafe.Pointer" not supported`},
	{reflect.TypeOf(map[*int64]string{}), `invalid key "*int64" in "map[*int64]string"`},
	{reflect.TypeOf(struct{ a int64 }{}), `type "struct { a int64 }" only has unexported fields`},
}

func rtErrorTestsAll() []rtErrorTest {
	// Start with base error tests
	tests := make([]rtErrorTest, len(rtErrorTests))
	copy(tests, rtErrorTests)
	tests = append(tests, reflectInfoErrorTests...)
	// Add some types we can generate via reflect
	for _, test := range tests {
		if test.rt != nil {
			tests = append(tests, rtErrorTest{reflect.PtrTo(test.rt), test.errstr})
			tests = append(tests, rtErrorTest{reflect.SliceOf(test.rt), test.errstr})
		}
	}
	// Now generate types from everything we have so far, for more complicated subtypes.
	for _, test := range tests {
		if test.rt != nil {
			tests = append(tests, rtErrorTest{reflect.PtrTo(reflect.PtrTo(test.rt)), test.errstr})
			tests = append(tests, rtErrorTest{reflect.SliceOf(reflect.SliceOf(test.rt)), test.errstr})
		}
	}
	return tests
}

func TestTypeFromReflectError(t *testing.T) {
	for _, test := range rtErrorTestsAll() {
		got, err := TypeFromReflect(test.rt)
		ExpectErr(t, err, test.errstr, "TypeFromReflect(%v)", test.rt)
		if got != nil {
			t.Errorf("TypeFromReflect(%v) got type %v, want nil", test.rt, got)
		}
	}
}

type simpleNamedType struct {
	X int16
}

// BenchmarkRepeatedVdlTypeOf determines the time for a repeated
// vdl.TypeOf, i.e. skipping the initial vdl.Type of that builds
// the type.
func BenchmarkRepeatedVdlTypeOf(b *testing.B) {
	val := &simpleNamedType{}
	TypeOf(val)

	for i := 0; i < b.N; i++ {
		TypeOf(val)
	}
}

// BenchmarkRepeatedReflectTypeOf is the reflect analog of
// BenchmarkRepeatedVdlTypeOf, for comparison purposes.
func BenchmarkRepeatedReflectTypeOf(b *testing.B) {
	reflect.TypeOf(&simpleNamedType{})

	for i := 0; i < b.N; i++ {
		reflect.TypeOf(&simpleNamedType{})
	}
}