var tests = []struct {
		val    interface{} // type as a value
		_32bit uintptr     // size on 32bit platforms
		_64bit uintptr     // size on 64bit platforms
	}{
		{Value{}, 72, 112},
		{Block{}, 164, 304},
		{LocalSlot{}, 28, 40},
		{valState{}, 28, 40},
	}

	for _, tt := range tests {
		want := tt._32bit
		if _64bit {
			want = tt._64bit
		}
		got := reflect.TypeOf(tt.val).Size()
		if want != got {

		}
	}

	// check that anything other than type and properties in metadata is forbidden
	tt = reflect.TypeOf(Structural{})
	for i := 0; i < tt.NumField(); i++ {
		s := Structural{}
		x := reflect.ValueOf(&s).Elem()
		fuzzer.Fuzz(x.Field(i).Addr().Interface())
		s.Type = "object"
		s.Properties = map[string]Structural{
			"name":         {},
			"generateName": {},
		}

		pem     string
		keyType reflect.Type
		errMsg  string
	}{
		"Invalid PEM string": {
			pem:    "Invalid PEM string",
			errMsg: "invalid PEM-encoded key",
		},
		"Invalid PEM block type": {
			pem:    certRSA,
			errMsg: "unsupported PEM block type for a private key: CERTIFICATE",
		},
		"Parse RSA key": {
			pem:     keyRSA,
			keyType: reflect.TypeOf(&rsa.PrivateKey{}),
		},

package main

import (
        "reflect"
        fake "./a" // 2nd package with name "reflect"
)

type T struct {
        _ fake.Type
}

func (T) f()            {}
func (T) G() (_ int)    { return }
func (T) H() (_, _ int) { return }

func main() {
        var x T
        typ := reflect.TypeOf(x)
        for i := 0; i < typ.NumMethod(); i++ {
                _ = typ.Method(i) // must not crash
        }

 *
 *  @version 2.3.77
 *  @website http://formvalidator.net/
 *  @author Victor Jonsson, http://victorjonsson.se
 *  @license MIT
 */

// assigned to interfaces, but only if reflect.Type.MethodByName is
// never used. Test it here.

package main

import reflect1 "reflect"

var called = false

type M int

func (m M) UniqueMethodName() {
	called = true
}

var v M

type MyType interface {
	MethodByName(string) (reflect1.Method, bool)
}

func main() {
	var t MyType = reflect1.TypeOf(v)
	m, _ := t.MethodByName("UniqueMethodName")

// license that can be found in the LICENSE file.

package main

import (
	"./a"
	"reflect"
)

var s = []rune{0, 1, 2, 3}

func main() {
	m := map[any]int{}
	k := reflect.New(reflect.ArrayOf(4, reflect.TypeOf(int32(0)))).Elem().Interface()
	m[k] = 1
	a.F()

// if the type is "indirectly" converted to an interface
// using reflection with a method descriptor as intermediate.
// However, it uses MethodByName() with a constant name of
// a method to look up. This does not disable the DCE like
// Method(0) does.

package main

import "reflect"

type S int

func (s S) M() { println("S.M") }

type I interface{ M() }

type T float64

    init {
        check(functionalInterface.java.isInterface)
        check(typeParameters.size <= 1) { "generic types with more than one type parameter are not supported" }
    }

    override fun getTypeConfiguredByLambda(type: KType): KType? =
        if (type.isSubtypeOf(starProjectedType)) type.arguments.firstOrNull()?.type ?: staticallyKnownConfiguredType else null

		}

		obj, _, err := t.serializer.Decode(body, nil, t.list.DeepCopyObject())
		if err != nil {
			return fmt.Errorf("decode request body: %v", err)
		}
		if reflect.TypeOf(obj).Elem() != reflect.TypeOf(t.list).Elem() {
			return fmt.Errorf("expected %T, got %T", t.list, obj)
		}
		t.onEvents(obj)
		return nil
	}()

	if err == nil {
		io.WriteString(w, "{}")
		return
	}