import org.gradle.api.logging.Logger;
import org.gradle.api.logging.Logging;

import javax.annotation.Nullable;
import javax.net.ssl.KeyManager;
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.TrustManagerFactory;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.security.KeyStore;

env TESTGO_VERSION=go1.22.0

! go mod tidy -go=1.21
stderr '^go: example.net/a@v0.1.0 requires go@1.22, but 1.21 is requested$'

-- go.mod --
module example

go 1.22

require example.net/a v0.1.0

replace example.net/a v0.1.0 => ./a
-- example.go --
package example

import "example.net/a"
-- a/go.mod --
module example.net/a

go 1.22
-- a/a.go --

	if lookupHost == nil {
		lookupHost = net.DefaultResolver.LookupHost
	}

	if baseDialCtx == nil {
		// This is same as which `http.DefaultTransport` uses.
		baseDialCtx = (&net.Dialer{
			Timeout:   30 * time.Second,
			KeepAlive: 30 * time.Second,
		}).DialContext
	}

	return func(ctx context.Context, network, addr string) (conn net.Conn, err error) {
		host, port, err := net.SplitHostPort(addr)
		if err != nil {

        when:
        performRequest()

        then:
        noExceptionThrown()
    }

    def "valid keystore file without specifying password"() {
        given:
        keyStore = TestKeyStore.init(resources.dir)
        setupSystemProperties()
        System.clearProperty("javax.net.ssl.keyStorePassword")

        when:
        performAuthenticatedRequest(false)

	if err != nil {
		err = &OpError{Op: "raw-control", Net: c.fd.net, Source: nil, Addr: c.fd.laddr, Err: err}
	}
	return err
}

func (c *rawConn) Read(f func(uintptr) bool) error {
	if !c.ok() {
		return syscall.EINVAL
	}
	err := c.fd.pfd.RawRead(f)
	runtime.KeepAlive(c.fd)
	if err != nil {
		err = &OpError{Op: "raw-read", Net: c.fd.net, Source: c.fd.laddr, Addr: c.fd.raddr, Err: err}
	}
	return err
}

	if mod != 0 {
		fmt.Println(ws2_32+":", "found")
	} else {
		fmt.Println(ws2_32+":", "not found")
	}
}
-- net.go --
//go:build net
package main

import _ "net"

func main() {
    hasModuleHandle()
}
-- nonet.go --
//go:build !net
package main

func main() {
    hasModuleHandle()

	{
		name: "kernel.shm_rmid_forced",
	}, {
		name: "net.ipv4.ip_local_port_range",
	}, {
		name: "net.ipv4.tcp_syncookies",
	}, {
		name: "net.ipv4.ping_group_range",
	}, {
		name: "net.ipv4.ip_unprivileged_port_start",
	}, {
		name:   "net.ipv4.ip_local_reserved_ports",
		kernel: utilkernel.IPLocalReservedPortsNamespacedKernelVersion,
	}, {
		name:   "net.ipv4.tcp_keepalive_time",

        "javax.net.ssl.trustStorePassword",
        "ssl.KeyManagerFactory.algorithm",
        "javax.net.ssl.keyStoreType",
        "javax.net.ssl.keyStore",
        "javax.net.ssl.keyStoreProvider",
        "javax.net.ssl.keyStorePassword",
        "java.home"
    );

    private final LoadingCache<Map<String, String>, SSLContext> cache = CacheBuilder.newBuilder().softValues().build(
        new SynchronizedSystemPropertiesCacheLoader()

-- go.mod --
module m

-- x.go --
package x

-- x_test.go --
package x
import "testing"
import _ "net/http"
func Test(t *testing.T) {}

-- broken/go.mod --
module broken
-- broken/http.go --
package broken

import (
	_ "net/http"
	_ "golang.org/x/net/http/httpproxy"

 */
package okhttp.regression.compare

import android.net.http.ConnectionMigrationOptions
import android.net.http.DnsOptions
import android.net.http.HttpEngine
import android.net.http.HttpException
import android.net.http.QuicOptions
import android.net.http.UrlRequest
import android.net.http.UrlRequest.Callback
import android.net.http.UrlRequest.REQUEST_PRIORITY_MEDIUM
import android.net.http.UrlResponseInfo