package net

import (
	"syscall"
	"testing"
)

const (
	syscall_TCP_KEEPIDLE  = syscall.TCP_KEEPIDLE
	syscall_TCP_KEEPCNT   = syscall.TCP_KEEPCNT
	syscall_TCP_KEEPINTVL = syscall.TCP_KEEPINTVL
)

type fdType = int

        return getTree().first(type, predicate)
    }

    @Override
    @SuppressWarnings("GrUnnecessaryPublicModifier")
    public <T extends BuildOperationType<?, ?>> boolean isType(BuildOperationRecord record, Class<T> type) {
        return getTree().isType(record, type)
    }

    @Override
    @SuppressWarnings("GrUnnecessaryPublicModifier")

            Value<? extends V> value = providerOfValue.calculateValue(consumer);
            if (value.isMissing()) {
                return value.asType();
            }
            collector.add(key, value.getWithoutSideEffect(), dest);
            return Value.present().withSideEffect(SideEffect.fixedFrom(value));
        }

        @Override

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

//go:build illumos

package net

import (
	"syscall"
	"testing"
	"time"
)

func getCurrentKeepAliveSettings(fd fdType) (cfg KeepAliveConfig, err error) {
	tcpKeepAlive, err := syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE)
	if err != nil {
		return
	}

//go:generate stringer -type=SymKind
const (
	Sxxx SymKind = iota
	STEXT
	SELFRXSECT
	SMACHOPLT

	// Read-only sections.
	STYPE
	SSTRING
	SGOSTRING
	SGOFUNC
	SGCBITS
	SRODATA
	SFUNCTAB

	SELFROSECT

	// Read-only sections with relocations.
	//
	// Types STYPE-SFUNCTAB above are written to the .rodata section by default.
	// When linking a shared object, some conceptually "read only" types need to

	"syscall"
	"testing"
)

const (
	syscall_TCP_KEEPIDLE  = windows.TCP_KEEPIDLE
	syscall_TCP_KEEPCNT   = windows.TCP_KEEPCNT
	syscall_TCP_KEEPINTVL = windows.TCP_KEEPINTVL
)

type fdType = syscall.Handle

func maybeSkipKeepAliveTest(t *testing.T) {
	// TODO(panjf2000): Unlike Unix-like OS's, old Windows (prior to Windows 10, version 1709)

package net

import (
	"testing"
	"time"
)

const (
	syscall_TCP_KEEPIDLE  = sysTCP_KEEPIDLE
	syscall_TCP_KEEPCNT   = sysTCP_KEEPCNT
	syscall_TCP_KEEPINTVL = sysTCP_KEEPINTVL
)

type fdType = int

func maybeSkipKeepAliveTest(_ *testing.T) {}

var testConfigs = []KeepAliveConfig{
	{
		Enable:   true,
		Idle:     20 * time.Second, // the minimum value is ten seconds on Solaris

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

//go:build solaris && !illumos

package net

import (
	"internal/syscall/unix"
	"syscall"
	"testing"
	"time"
)

func getCurrentKeepAliveSettings(fd fdType) (cfg KeepAliveConfig, err error) {
	tcpKeepAlive, err := syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_KEEPALIVE)
	if err != nil {
		return
	}

	var (
		tcpKeepAliveIdle         int

		if isProxy(con) || isZtunnel(con) {
			xdsConfigs := make([]*status.ClientConfig_GenericXdsConfig, 0)
			for _, stype := range stypes {
				pxc := &status.ClientConfig_GenericXdsConfig{}
				if watchedResource, ok := con.proxy.WatchedResources[stype]; ok {
					pxc.ConfigStatus = debugSyncStatus(watchedResource)
				} else if isZtunnel(con) {
					pxc.ConfigStatus = status.ConfigStatus_UNKNOWN

        MethodHandle decorated = MethodHandles.insertArguments(INTERCEPTOR, 0, this, spreader, flags, caller.lookupClass().getName());
        return decorated.asCollector(Object[].class, original.type().parameterCount()).asType(original.type());
    }

    private Object interceptMethodHandle(MethodHandle original, int flags, String consumer, Object[] args) throws Throwable {
        boolean isSpread = (flags & IndyInterface.SPREAD_CALL) != 0;