smbAuth.setServer(hostname);
                    if (StringUtil.isNotBlank(port)) {
                        try {
                            smbAuth.setPort(Integer.parseInt(port));
                        } catch (final NumberFormatException e) {
                            logger.warn("Failed to parse {}", port, e);
                        }
                    }
                    smbAuth.setUsername(username);

  }

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

    try {
      result.connect(new InetSocketAddress(host, port));
    } catch (IOException e) {
      result.close();
      throw e;
    }
    return result;
  }

  @Override public Socket createSocket(

    NameServiceClient() {
        this(LPORT, LADDR);
    }

    NameServiceClient(final int lport, final InetAddress laddr) {
        this.lport = lport;
        this.laddr = laddr;

        try {
            baddr = Config.getInetAddress("jcifs.smb1.netbios.baddr", InetAddress.getByName("255.255.255.255"));
        } catch (final UnknownHostException uhe) {}

        snd_buf = new byte[SND_BUF_SIZE];

	pkill minio || sudo pkill minio
	pkill -9 minio || sudo pkill -9 minio
	rm -rf /tmp/minio{1,2}
	echo "done"
}

cleanup

export MINIO_CI_CD=1
export MINIO_BROWSER=off
export MINIO_ROOT_USER="minio"
export MINIO_ROOT_PASSWORD="minio123"
TEST_MINIO_ENC_KEY="MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDA"

# Create certificates for TLS enabled MinIO

    }

    public void setPort_Avg(ConditionOptionCall<AvgAggregationBuilder> opLambda) {
        setPort_Avg("port", opLambda);
    }

    public void setPort_Avg(String name, ConditionOptionCall<AvgAggregationBuilder> opLambda) {
        AvgAggregationBuilder builder = regAvgA(name, "port");
        if (opLambda != null) {
            opLambda.callback(builder);
        }
    }

WORK_DIR="$PWD/.verify-$RANDOM"
MINIO_CONFIG_DIR="$WORK_DIR/.minio"
MINIO=("$PWD/minio" --config-dir "$MINIO_CONFIG_DIR" server)

function start_minio_3_node() {
	export MINIO_ROOT_USER=minio
	export MINIO_ROOT_PASSWORD=minio123
	export MINIO_ERASURE_SET_DRIVE_COUNT=6
	export MINIO_CI_CD=1

	start_port=$1
	args=""
	for i in $(seq 1 3); do

   * Starts the server on the loopback interface for the given port.
   *
   * @param port the port to listen to, or 0 for any available port. Automated tests should always
   * use port 0 to avoid flakiness when a specific port is unavailable.
   */
  @Throws(IOException::class)
  @JvmOverloads
  public fun start(port: Int = 0) {
    start(InetAddress.getByName("localhost"), port)
  }

  /**

 */
public class CrawlerWebServer {
    private int port = 8080;

    private File docRoot;

    private Server server;

    private boolean tempDocRoot = false;

    public CrawlerWebServer(final int port) {
        this(port, createDocRoot(3));
        tempDocRoot = true;
    }

    public CrawlerWebServer(final int port, final File docRoot) {
        this.port = port;
        this.docRoot = docRoot;

	wget --quiet -O mc https://dl.minio.io/client/mc/release/linux-amd64/mc &&
		chmod +x mc
fi

export CI=true
export MINIO_KMS_AUTO_ENCRYPTION=on
export MINIO_KMS_SECRET_KEY=my-minio-key:OSMM+vkKUTCvQs9YL/CVMIMt43HFhkUpqJxTmGl6rYw=

(minio server http://localhost:9000/tmp/xl/{1...10}/disk{0...1} 2>&1 >/dev/null) &
pid=$!

export MC_HOST_myminio="http://minioadmin:minioadmin@localhost:9000/"

./mc ready myminio

    }

    @Nested
    @DisplayName("Default Port Tests")
    class DefaultPortTests {

        @Test
        @DisplayName("Should return HTTPS port 443")
        void testGetDefaultPort() {
            // When
            int port = handler.getDefaultPort();

            // Then
            assertEquals(443, port);
            assertEquals(Handler.DEFAULT_HTTPS_PORT, port);
        }

        @Test