{":0", "", "0"},
		{"server:https", "server", "443"},
		{"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)
		}
	}
}

	}
	m.handlers.init()
	if ctx == nil {
		ctx = context.Background()
	}

	for _, host := range o.Hosts {
		if host == o.Local {
			if found {
				return nil, fmt.Errorf("grid: local host found multiple times")
			}
			found = true
			// No connection to local.
			continue
		}
		m.targets[host] = newConnection(connectionParams{
			ctx:           ctx,
			id:            m.ID,

    assertThat(calls.size).isEqualTo(1)
    val url = server.url("/").toUrl()
    val call = calls[0]
    assertThat(call).contains("host=" + url.host)
    assertThat(call).contains("port=" + url.port)
    assertThat(call).contains("site=" + url.host)
    assertThat(call).contains("url=$url")
    assertThat(call).contains("type=" + java.net.Authenticator.RequestorType.SERVER)

		},
		// Keys and input order of k=v is same.
		{
			input: `connection_string="host=localhost port=2832" comment="really long comment"`,
			keys:  []string{"connection_string", "comment"},
			expectedFields: map[string]struct{}{
				`connection_string="host=localhost port=2832"`: {},
				`comment="really long comment"`:                {},
			},
		},
		// Keys with spaces in between
		{

  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)

      .assertLogMatch(Regex("""dnsStart: ${url.host}"""))
      .assertLogMatch(Regex("""dnsEnd: \[.+]"""))
      .assertLogMatch(Regex("""connectStart: ${url.host}/.+ DIRECT"""))
      .assertLogMatch(Regex("""connectEnd: http/1.1"""))
      .assertLogMatch(
        Regex(
          """connectionAcquired: Connection\{${url.host}:\d+, proxy=DIRECT hostAddress=${url.host}/.+ cipherSuite=none protocol=http/1\.1\}""",
        ),

StandardCrawlerContainer container = new StandardCrawlerContainer();

// Configure HTTP client with custom settings
container.singleton("httpClient", HcHttpClient.class, client -> {
    client.setUserAgent("MyBot/1.0");
    client.setConnectionTimeout(30000);
    client.setMaxConnections(100);
});

// Configure URL filtering
container.singleton("urlFilter", UrlFilterImpl.class, filter -> {

    // If the non-host fields of the address don't overlap, we're done.
    if (!this.route.address.equalsNonHost(address)) return false

    // If the host exactly matches, we're done: this connection can carry the address.
    if (address.url.host ==
      this
        .route()
        .address.url.host
    ) {
      return true // This connection is a perfect match.
    }

  }

  /**
   * Returns a string representation of the host specifier suitable for inclusion in a URI. If the
   * host specifier is a domain name, the string will be normalized to all lower case. If the
   * specifier was an IPv6 address without brackets, brackets are added so that the result will be
   * usable in the host part of a URI.
   */
  @Override
  public String toString() {

        super();
    }

    /**
     * The unique identifier of the duplicate host configuration being edited.
     * This is a required field for identifying which duplicate host entry to update.
     */
    @Required
    @Size(max = 1000)
    public String id;

    /**
     * The username of the user who last updated this duplicate host configuration.
     * Used for audit trail purposes to track who made changes.
     */