const (
	fakeObjectItemsNum = 1000
	exemptObjectIndex  = fakeObjectItemsNum / 4
)

type SampleSpec struct {
	Flied int
}

type FooSpec struct {
	Flied int
}

type FooList struct {
	metav1.TypeMeta
	metav1.ListMeta
	Items []Foo
}

func (s *FooList) DeepCopyObject() runtime.Object { panic("unimplemented") }

type SampleList struct {
	metav1.TypeMeta
	metav1.ListMeta
	Items []Sample
}

		}
	}

	// 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": {},
		}

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
        }

// 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")

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

// 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()

		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{}),
		},

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

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// See issue 44207.

package main

import "reflect"

type S int

func (s S) M() {}

func main() {
	t := reflect.TypeOf(S(0))
	fn, ok := reflect.PointerTo(t).MethodByName("M")
	if !ok {
		panic("FAIL")
	}
	fn.Func.Call([]reflect.Value{reflect.New(t)})

import (
	"fmt"
	"reflect"
)

func f(next func() bool) {
	for b := next(); b; b = next() {
		fmt.Printf("next() returned %v\n", b)
	}
}

func main() {
	next := reflect.MakeFunc(reflect.TypeOf((func() bool)(nil)), func(_ []reflect.Value) []reflect.Value {
		return []reflect.Value{reflect.ValueOf(false)}
	})
	reflect.ValueOf(f).Call([]reflect.Value{next})