localAddress = new SocketInetAddress(localSocketAddress.getAddress(), localSocketAddress.getPort());
        InetSocketAddress remoteSocketAddress = (InetSocketAddress) socket.socket().getRemoteSocketAddress();
        remoteAddress = new SocketInetAddress(remoteSocketAddress.getAddress(), remoteSocketAddress.getPort());
        objectReader = messageSerializer.newReader(streamSerializer.newDecoder(instr));

                // only care about HTTP hosts right now
                if (repositoryUrl.getScheme().startsWith("http")) {
                    authenticationInternal.addHost(repositoryUrl.getHost(), repositoryUrl.getPort());
                }
            }
        }
        return configuredAuthentication;
    }

    protected Collection<URI> getRepositoryUrls() {
        return Collections.emptyList();
    }

                            proxyInfo.setHost(proxy.getHost());
                            proxyInfo.setType(proxy.getProtocol());
                            proxyInfo.setPort(proxy.getPort());
                            proxyInfo.setNonProxyHosts(proxy.getNonProxyHosts());
                            proxyInfo.setUserName(proxy.getUsername());
                            proxyInfo.setPassword(proxy.getPassword());

        return new Statement() {
            @Override
            void evaluate() throws Throwable {
                base.evaluate()
                close()
            }
        }
    }

    def getPort() {
        port
    }

    def connect() {
        if (vm == null) {
            def vmm = bootstrapClass.virtualMachineManager()

     */
    public void setPassword(String password) {
        this.password = password;
    }

    /**
     * Get the proxy port.
     *
     * @return proxy server port
     */
    public int getPort() {
        return port;
    }

    /**
     * Set the proxy port.
     *
     * @param port proxy server port
     */
    public void setPort(int port) {
        this.port = port;
    }

        given:
        httpBuildCacheServer.start()
        def safeUri = httpBuildCacheServer.uri
        def basicAuthUri = new URI(safeUri.getScheme(), 'user:pwd', safeUri.getHost(), safeUri.getPort(), safeUri.getPath(), safeUri.getQuery(), safeUri.getFragment())
        settingsFile << """
            buildCache {
                remote(org.gradle.caching.http.HttpBuildCache) {
                    enabled = true

            for (AuthenticationInternal.HostAndPort hostAndPort : hostsForAuthentication) {
                String host = hostAndPort.getHost();
                int port = hostAndPort.getPort();

                assert host != null : "HTTP credentials and authentication require a host scope to be defined as well";

                if (credentials instanceof HttpHeaderCredentials) {

    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbResourceLocator#getPort()
     */
    @Override
    public int getPort () {
        return this.url.getPort();
    }


    /**
     * {@inheritDoc}
     *
     * @see jcifs.SmbResourceLocator#getURL()
     */
    @Override
    public URL getURL () {

 *
 * <p>Example usage:
 *
 * <pre>
 * HostAndPort hp = HostAndPort.fromString("[2001:db8::1]")
 *     .withDefaultPort(80)
 *     .requireBracketsForIPv6();
 * hp.getHost();   // returns "2001:db8::1"
 * hp.getPort();   // returns 80
 * hp.toString();  // returns "[2001:db8::1]:80"
 * </pre>
 *
 * <p>Here are some examples of recognized formats:
 *
 * <ul>
 *   <li>example.com
 *   <li>example.com:80
 *   <li>192.0.2.1

    }
  }

  @JvmName("-deprecated_port")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "port"),
    level = DeprecationLevel.ERROR,
  )
  fun getPort(): Int = port

  fun toProxyAddress(): Proxy {
    before() // This implicitly starts the delegate.
    return delegate.toProxyAddress()
  }

  @JvmName("-deprecated_serverSocketFactory")
  @Deprecated(