),
        localPort = 80,
      )
    val request = RecordedRequest("GET / HTTP/1.1", headers, emptyList(), 0, Buffer(), 0, socket)
    assertThat(request.requestUrl.toString()).isEqualTo("http://host-from-header.com/")
  }

  private class FakeSocket(
    private val localAddress: InetAddress,
    private val localPort: Int,
    private val remoteAddress: InetAddress = localAddress,

        assert server.started
        if (sslConnector) {
            return URI.create("https://localhost:${sslConnector.localPort}")
        } else if (useHostnameForUrl) {
            // If used in a code-path that interacts with the HttpClientHelper, this will fail validation.
            return URI.create("http://localhost:${connector.localPort}")
        } else {

    public NbtSocket( NbtAddress address, int port,
                                InetAddress localAddr, int localPort ) throws IOException {
        this( address, null, port, localAddr, localPort );
    }
    public NbtSocket( NbtAddress address, String calledName, int port,
                                InetAddress localAddr, int localPort ) throws IOException {
        super( address.getInetAddress(), ( port == 0 ? SSN_SRVC_PORT : port ),

  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
    localAddress: InetAddress,
    localPort: Int,
  ): SSLSocket {
    val sslSocket = delegate.createSocket(host, port, localAddress, localPort) as SSLSocket
    return configureSocket(sslSocket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: InetAddress,
    port: Int,

  }

  @Throws(IOException::class)
  override fun createSocket(
    host: String,
    port: Int,
    localAddress: InetAddress,
    localPort: Int,
  ): Socket {
    val socket = delegate.createSocket(host, port, localAddress, localPort)
    return configureSocket(socket)
  }

  @Throws(IOException::class)
  override fun createSocket(
    host: InetAddress,
    port: Int,
  ): Socket {

    }

    @Override public Socket createSocket(
        String host, int port, InetAddress localHost, int localPort) throws IOException {
      return configureSocket((SSLSocket) delegate.createSocket(host, port, localHost, localPort));
    }

    @Override public Socket createSocket(InetAddress host, int port) throws IOException {

func newPortForwarder(c *client, podName, ns, localAddress string, localPort, podPort int) (PortForwarder, error) {
	if localAddress == "" {
		localAddress = defaultLocalAddress
	}
	f := &forwarder{
		stopCh:       make(chan struct{}),
		restConfig:   c.config,
		podName:      podName,
		ns:           ns,
		localAddress: localAddress,
		localPort:    localPort,
		podPort:      podPort,
	}

	return f, nil
}

    boolean useUnicode = USE_UNICODE;
    String tconHostName = null;

    SmbTransport( UniAddress address, int port, InetAddress localAddr, int localPort ) {
        this.address = address;
        this.port = port;
        this.localAddr = localAddr;
        this.localPort = localPort;
    }

    synchronized SmbSession getSmbSession() {
        return getSmbSession( new NtlmPasswordAuthentication( null, null, null ));
    }

      val scheme = if (socket is SSLSocket) "https" else "http"
      val localPort = socket.localPort
      val hostAndPort =
        headers[":authority"]
          ?: headers["Host"]
          ?: when (val inetAddress = socket.localAddress) {
            is Inet6Address -> "[${inetAddress.hostAddress}]:$localPort"
            else -> "${inetAddress.hostAddress}:$localPort"
          }

    host: String,
    port: Int,
    localHost: InetAddress,
    localPort: Int,
  ): Socket = TODO("Not yet implemented")

  override fun createSocket(
    host: InetAddress,
    port: Int,
  ): Socket = TODO("Not yet implemented")

  override fun createSocket(
    address: InetAddress,
    port: Int,
    localAddress: InetAddress,
    localPort: Int,
  ): Socket = TODO("Not yet implemented")