tests := []struct {
		name    string
		keyHex  string
		keyType reflect.Type
		curve   elliptic.Curve
	}{
		{
			name:    "RSA private key",
			keyHex:  pkcs8RSAPrivateKeyHex,
			keyType: reflect.TypeOf(&rsa.PrivateKey{}),
		},
		{
			name:    "P-224 private key",
			keyHex:  pkcs8P224PrivateKeyHex,
			keyType: reflect.TypeOf(&ecdsa.PrivateKey{}),
			curve:   elliptic.P224(),
		},
		{

//

// Package testing is a generated GoMock package.
package testing

import (
	context "context"
	io "io"
	url "net/url"
	reflect "reflect"
	time "time"

	gomock "go.uber.org/mock/gomock"
	v1 "k8s.io/api/core/v1"
	types "k8s.io/apimachinery/pkg/types"
	remotecommand "k8s.io/client-go/tools/remotecommand"

		}
	}
	return false
}

func AssertEqual(x, y interface{}) bool {
	if reflect.DeepEqual(x, y) {
		return true
	}
	if x == nil || y == nil {
		return false
	}

	xval := reflect.ValueOf(x)
	yval := reflect.ValueOf(y)
	if xval.Kind() == reflect.Ptr && xval.IsNil() ||
		yval.Kind() == reflect.Ptr && yval.IsNil() {
		return false
	}

	if valuer, ok := x.(driver.Valuer); ok {

	// we use reflect to find all such references.
	if len(badNils) > 0 {
		exprType := reflect.TypeFor[ast.Expr]()
		exprSliceType := reflect.TypeFor[[]ast.Expr]()
		walk(f, func(n any) {
			if n == nil {
				return
			}
			v := reflect.ValueOf(n)
			if v.Type().Kind() != reflect.Pointer {
				return
			}
			if v.IsNil() {
				return
			}

		GroupName:          GroupName,
		SchemeGroupVersion: SchemeGroupVersion,
		AddToScheme:        AddToScheme,
		AllowedTags: map[reflect.Type]bool{
			reflect.TypeOf(metav1.TypeMeta{}):              true,
			reflect.TypeOf(metav1.Duration{}):              true,
			reflect.TypeOf(logsapi.LoggingConfiguration{}): true,
		},
	}

	if err := componentconfigtesting.VerifyInternalTypePackage(pkginfo); err != nil {

	// runtime.timeTimer (exported for testing as TimeTimer)
	// must have time.Timer and time.Ticker as a prefix
	// (meaning those two must have the same layout).
	runtimeTimeTimer := reflect.TypeOf(runtime.TimeTimer{})

	check := func(name string, typ reflect.Type) {
		n1 := runtimeTimeTimer.NumField()
		n2 := typ.NumField()
		if n1 != n2+1 {
			t.Errorf("runtime.TimeTimer has %d fields, want %d (%s has %d fields)", n1, n2+1, name, n2)

// Test that we can inline the receiver arguments for
// reflect.Value.UnsafeAddr/Pointer, even in checkptr mode.

package main

import (
	"reflect"
	"unsafe"
)

func main() {
	n := 10                      // ERROR "moved to heap: n"
	m := make(map[string]string) // ERROR "moved to heap: m" "make\(map\[string\]string\) escapes to heap"

	_ = unsafe.Pointer(reflect.ValueOf(&n).Elem().UnsafeAddr()) // ERROR "inlining call"

		gvkToType:                 map[schema.GroupVersionKind]reflect.Type{},
		typeToGVK:                 map[reflect.Type][]schema.GroupVersionKind{},
		unversionedTypes:          map[reflect.Type]schema.GroupVersionKind{},
		unversionedKinds:          map[string]reflect.Type{},
		fieldLabelConversionFuncs: map[schema.GroupVersionKind]FieldLabelConversionFunc{},
		defaulterFuncs:            map[reflect.Type]func(interface{}){},

package typemap

import (
	"reflect"

	"istio.io/istio/pkg/ptr"
)

// TypeMap provides a map that holds a map of Type -> Value. There can be only a single value per type.
// The value stored for a type must be of the same type as the key.
type TypeMap struct {
	inner map[reflect.Type]any
}

func NewTypeMap() TypeMap {
	return TypeMap{make(map[reflect.Type]any)}
}

func Set[T any](t TypeMap, v T) {

import com.google.common.collect.Ordering;
import groovy.lang.GroovyObject;
import org.gradle.internal.reflect.GroovyMethods;
import org.gradle.internal.reflect.Types.TypeVisitResult;
import org.gradle.internal.reflect.Types.TypeVisitor;
import org.gradle.model.Managed;

import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Proxy;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;