proxySelector.proxies.add(Proxy(Proxy.Type.HTTP, socketAddress))

    // Define two host names for the DNS routing of fake proxy servers
    val proxyServer1 = InetAddress.getByAddress("proxyServer1", byteArrayOf(127, 0, 0, 2))
    val proxyServer2 = InetAddress.getByAddress("proxyServer2", byteArrayOf(127, 0, 0, 3))

    println("Proxy Server 1 is ${server1.inetSocketAddress}")
    println("Proxy Server 2 is ${server2.inetSocketAddress}")

        proxyServer.start(recordingServer)
        proxyServer.configureProxy(executer)
        fails('listJars') // Don't have to succeed here, just record the attempt in the fake proxy and verify it
        then:
        result.assertTaskExecuted(":listJars")
        recordingServer.madeAnyConnection()

        when:
        proxyServer.stop()
        proxyServer.configureProxy(executer)

        if (isTunnel()) {
            proxyServer.requestCount == 1
        } else {
            proxyServer.requestCount == 2
        }
    }

    def "reports proxy not running at configured location"() {
        given:
        proxyServer.start()
        proxyServer.stop()
        setupServer()

        and:
        buildFile << """
repositories {
    maven { url "${repoServerUrl}" }
}
"""
        when:

}

var unsupportedError = fmt.Errorf(runtime.GOOS + "/" + runtime.GOARCH + "is unsupported")

// platformSetup is called after setting up the ProxyServer, but before creating the
// Proxier. It should fill in any platform-specific fields and perform other
// platform-specific setup.
func (s *ProxyServer) platformSetup(ctx context.Context) error {
	return unsupportedError
}

                "-Dhttp.proxyPort=${proxyServer.port}",
                "-Dhttp.nonProxyHosts=foo",
                "-Dhttp.proxyUser=proxyUser",
                "-Dhttp.proxyPassword=proxyPassword"
        )

        then:
        succeeds 'retrieve'

        and:
        proxyServer.port != server.port
        proxyServer.requestCount == 2
    }

	proxyconfigapi "k8s.io/kubernetes/pkg/proxy/apis/config"
	proxyconfig "k8s.io/kubernetes/pkg/proxy/config"
	"k8s.io/utils/ptr"
)

type HollowProxy struct {
	ProxyServer *proxyapp.ProxyServer
}

type FakeProxier struct {
	proxyconfig.NoopNodeHandler
}

func (*FakeProxier) Sync() {}
func (*FakeProxier) SyncLoop() {
	select {}
}

// Run runs the specified ProxyServer.
func (s *fakeProxyServerLongRun) Run(ctx context.Context) error {
	for {
		time.Sleep(2 * time.Second)
	}
}

// CleanupAndExit runs in the specified ProxyServer.
func (s *fakeProxyServerLongRun) CleanupAndExit() error {
	return nil
}

type fakeProxyServerError struct{}

// Run runs the specified ProxyServer.

    systemProp.http.proxyHost=localhost
    systemProp.http.proxyPort=${proxyServer.port}
    systemProp.http.nonProxyHosts=
"""
        when:
        def result = wrapperExecuter.withTasks('hello').run()

        then:
        assertThat(result.output, containsString('hello'))

        and:
        proxyServer.requestCount == 1
    }

    def "downloads wrapper via authenticated proxy"() {

    }

    def "downloads wrapper via proxy"() {
        given:
        proxyServer.start()

        // Note that the HTTPS protocol handler uses the same nonProxyHosts property as the HTTP protocol.
        file("gradle.properties") << """
    systemProp.https.proxyHost=localhost
    systemProp.https.proxyPort=${proxyServer.port}
    systemProp.http.nonProxyHosts=
"""

		config.Winkernel.RootHnsEndpointName = "cbr0"
	}
}

// platformSetup is called after setting up the ProxyServer, but before creating the
// Proxier. It should fill in any platform-specific fields and perform other
// platform-specific setup.
func (s *ProxyServer) platformSetup(ctx context.Context) error {
	// Preserve backward-compatibility with the old secondary IP behavior