package types2

import (
	"reflect"
	"testing"
)

// Signal size changes of important structures.

func TestSizeof(t *testing.T) {
	const _64bit = ^uint(0)>>32 != 0

	var tests = []struct {
		val    interface{} // type as a value
		_32bit uintptr     // size on 32bit platforms
		_64bit uintptr     // size on 64bit platforms
	}{
		// Types
		{Basic{}, 16, 32},
		{Array{}, 16, 24},

	Group:         "testdata.istio.io",
	Kind:          "Kind1",
	Plural:        "Kind1s",
	Version:       "v1alpha1",
	Proto:         "google.protobuf.Struct",
	ReflectType:   reflect.TypeOf(&structpb.Struct{}).Elem(),
	ProtoPackage:  "github.com/gogo/protobuf/types",
	ClusterScoped: false,
	ValidateProto: validation.EmptyValidate,
}.MustBuild()

func createTestResource(t *testing.T, ns, name, version string) *resource.Instance {
	t.Helper()

 *
 * The public type of an object is the one exposed to statically-typed consumers, such as Kotlin build scripts, by default.
 *
 * @since 3.5
 */
public interface HasPublicType {

    /**
     * Public type.
     *
     * @return this object's public type
     */
    TypeOf<?> getPublicType();

	default:
		return nil, fmt.Errorf("unsupported PEM block type for a private key: %s", kb.Type)
	}
}

// GetRSAKeySize returns the size if it is RSA key, otherwise it returns an error.
func GetRSAKeySize(privKey crypto.PrivateKey) (int, error) {
	if t := reflect.TypeOf(privKey); t != reflect.TypeOf(&rsa.PrivateKey{}) {
		return 0, fmt.Errorf("key type is not RSA: %v", t)
	}
	pkey := privKey.(*rsa.PrivateKey)

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

            function.annotations.any { it is Adding } -> {
                check(inType != null)

                check(function.returnType != typeOf<Unit>() || configureLambdas.getTypeConfiguredByLambda(function.parameters.last().type) == null) {
                    "an @Adding function with a Unit return type may not accept configuring lambdas"
                }

/*
 Copyright (C) Federico Zivolo 2017
 Distributed under the MIT License (license terms are at http://opensource.org/licenses/MIT).

	badPtr = uintptr(unsafe.Pointer(&b[len(b)-1])) + 1
}

type ft func() *int

var fn ft

func rf([]reflect.Value) []reflect.Value {
	a := reflect.ValueOf((*int)(nil))
	return []reflect.Value{a}
}

const N = 1000

func main() {
	fn = reflect.MakeFunc(reflect.TypeOf(fn), rf).Interface().(ft)

	// Keep running GC so the write barrier is on.
	go func() {

)

// 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) {
	interfaceType := reflect.TypeOf((*T)(nil)).Elem()
	t.inner[interfaceType] = v
}

func TestX[T any]() { Test[T, interface{ XBad() }, interface{ XGood() }]() }

type E struct{}

//go:nointerface
func (E) EBad()  {}
func (E) EGood() {}

type X[T any] struct{ E }

//go:nointerface
func (X[T]) XBad()  {}
func (X[T]) XGood() {}

type W struct{ X[int] }

func main() {
	_ = E.EGood
	_ = E.EBad

	TestE[E]()

	_ = X[int].EGood