return d.r.Read(p)
	}
	return 0, errors.New("reader closed")
}

func (d *disconnectReader) Close() error {
	d.mu.Lock()
	d.r = nil
	d.mu.Unlock()
	return nil
}

func untar(ctx context.Context, r io.Reader, putObject func(reader io.Reader, info os.FileInfo, name string) error, o untarOptions) error {
	bf := bufio.NewReader(r)
	switch f := detect(bf); f {
	case formatGzip:

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/util/intstr"
	v1listers "k8s.io/client-go/listers/core/v1"
	"k8s.io/client-go/tools/cache"
)

func TestResolve(t *testing.T) {
	matchingEndpoints := func(svc *v1.Service) []*v1.Endpoints {
		ports := []v1.EndpointPort{}
		for _, p := range svc.Spec.Ports {
			if p.TargetPort.Type != intstr.Int {
				continue
			}

			object.Spec.Ingress = []networking.NetworkPolicyIngressRule{
				{
					Ports: []networking.NetworkPolicyPort{
						{
							Protocol: &protocolICMP,
							Port:     &intstr.IntOrString{Type: intstr.Int, IntVal: 80},
						},
					},
				},
			}
			return object
		},
	)
}

func TestDelete(t *testing.T) {
	storage, server := newStorage(t)
	defer server.Terminate(t)

			return nil
		}

		var probePort *intstr.IntOrString
		if p.HTTPGet != nil {
			probePort = &p.HTTPGet.Port
		} else {
			probePort = &p.TCPSocket.Port
		}

		if probePort.Type == intstr.String {
			port, exists := portMap[probePort.StrVal]
			if !exists {
				return nil
			}
			*probePort = intstr.FromInt32(port)
		} else if probePort.IntVal == targetPort {
			// Already is rewritten

					Protocol:   "TCP",
					TargetPort: intstr.IntOrString{Type: intstr.Int, IntVal: 7442},
				},
				{
					Name:       "tcp-8443",
					Port:       8443,
					Protocol:   "TCP",
					TargetPort: intstr.IntOrString{Type: intstr.Int, IntVal: 7442},
				},
				{
					Name:       "http-7557",
					Port:       7557,
					Protocol:   "TCP",
					TargetPort: intstr.IntOrString{Type: intstr.Int, IntVal: 7442},
				},

	isDefault := func(item any) bool {
		var ii intstr.IntOrString
		switch item := item.(type) {
		case int:
			ii = intstr.FromInt32(int32(item))
		case int64:
			ii = intstr.FromInt32(int32(item))
		case string:
			ii = intstr.FromString(item)
		default:
			ii = intstr.FromInt32(0)
		}
		intVal, err := intstr.GetScaledValueFromIntOrPercent(&ii, 100, false)
		if err != nil || intVal == 0 {
			return true
		}

func (intMapType) NewMap() Map {
	return make(intMap)
}

var deadcafe = []byte("\xDE\xAD\xCA\xFE")

type intMap map[int][]byte

func (m intMap) AddItem() {
	s0 := len(m)
	for len(m) == s0 {
		key := rand.Intn(s0 + 1)
		m[key] = make([]byte, rand.Intn(64<<10))
	}
}

func (m intMap) DelItem() {
	for k := range m {
		delete(m, k)
		return
	}
}

func (m intMap) GetItem() {
	key := rand.Intn(len(m))

class AbstractKotlinDslScriptsModelCrossVersionSpec extends AbstractKotlinScriptModelCrossVersionTest {

    protected BuildSpec withBuildSrcAndInitScripts() {
        withBuildSrc()

        def initJar = withEmptyJar("classes_init.jar")
        def someInitJar = withEmptyJar("classes_some_init.jar")

        toolingApi.requireIsolatedUserHome()
        def gradleUserHomeDir = toolingApi.createExecuter().gradleUserHomeDir

	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/fields"
	"k8s.io/apimachinery/pkg/labels"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/util/intstr"
	genericapirequest "k8s.io/apiserver/pkg/endpoints/request"
	"k8s.io/apiserver/pkg/registry/generic"
	genericregistrytest "k8s.io/apiserver/pkg/registry/generic/testing"
	"k8s.io/apiserver/pkg/registry/rest"

	t any
	b bool
}{
	{new(chan int), new(<-chan int), true},
	{new(<-chan int), new(chan int), false},
	{new(*int), new(IntPtr), true},
	{new(IntPtr), new(*int), true},
	{new(IntPtr), new(IntPtr1), false},
	{new(Ch), new(<-chan any), true},
	// test runs implementsTests too
}

type IntPtr *int
type IntPtr1 *int
type Ch <-chan any

func TestAssignableTo(t *testing.T) {