}

    /**
     * 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;
    }

    /**
     * Get the proxy username.
     *

      return configureSocket((SSLSocket) delegate.createSocket(host, port, localHost, localPort));
    }

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

    @Override public Socket createSocket(

    /**
     * Get transport connection, with local binding
     *
     * @param tc
     *            context to use
     * @param address the server address
     * @param port the port number
     * @param localAddr the local address to bind to
     * @param localPort the local port to bind to
     * @param hostName the server host name

     *
     * @param address the NetBIOS address to connect to
     * @param port the port number, or 0 for the default NetBIOS session service port
     * @throws IOException if an I/O error occurs while creating the socket
     */
    public NbtSocket(final NbtAddress address, final int port) throws IOException {
        this(address, port, null, 0);
    }

    /**

			}
			port, err = strconv.Atoi(portStr)
			if err != nil {
				logger.Fatal(fmt.Errorf("invalid arguments passed to --ftp=%s (%v)", arg, err), "unable to start FTP server")
			}
			if port < 1 || port > 65535 {
				logger.Fatal(fmt.Errorf("invalid arguments passed to --ftp=%s, (port number must be between 1 to 65535)", arg), "unable to start FTP server")
			}

    return configureSocket(sslSocket)
  }

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

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

  @Throws(IOException::class)
  override fun createServerSocket(port: Int): ServerSocket {
    val serverSocket = delegate.createServerSocket(port)
    return configureServerSocket(serverSocket)
  }

  @Throws(IOException::class)
  override fun createServerSocket(
    port: Int,
    backlog: Int,
  ): ServerSocket {
    val serverSocket = delegate.createServerSocket(port, backlog)
    return configureServerSocket(serverSocket)
  }

  override fun createSocket(
    host: String,
    port: Int,
  ): Socket {
    val socket = delegate.createSocket(host, port)
    return configureSocket(socket)
  }

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

package main

import (
	"bytes"
	"encoding/json"
	"flag"
	"fmt"
	"io"
	"log"
	"net/http"
)

var port int

func init() {
	flag.IntVar(&port, "port", 8080, "Port to listen on")
}

func mainHandler(w http.ResponseWriter, r *http.Request) {
	body, err := io.ReadAll(r.Body)
	defer r.Body.Close()
	if err != nil {

		{"server:http", "server", "80"},
	}

	for _, testCase := range testCases {
		host, port := mustSplitHostPort(testCase.hostPort)
		if testCase.expectedHost != host {
			t.Fatalf("host: expected = %v, got = %v", testCase.expectedHost, host)
		}

		if testCase.expectedPort != port {
			t.Fatalf("port: expected = %v, got = %v", testCase.expectedPort, port)
		}
	}
}

func TestSortIPs(t *testing.T) {
	testCases := []struct {