val routeSelector = newRouteSelector(address)
    dns[uriHost] = dns.allocate(2)
    val selection = routeSelector.next()
    dns.assertRequests(uriHost)
    val routes = selection.routes
    assertRoute(routes[0], address, Proxy.NO_PROXY, dns.lookup(uriHost, 0), uriPort)
    assertRoute(routes[1], address, Proxy.NO_PROXY, dns.lookup(uriHost, 1), uriPort)
    assertThat(selection.next()).isSameAs(routes[0])

    private fun domainMatch(
      urlHost: String,
      domain: String,
    ): Boolean {
      if (urlHost == domain) {
        return true // As in 'example.com' matching 'example.com'.
      }

      return urlHost.endsWith(domain) &&
        urlHost[urlHost.length - domain.length - 1] == '.' &&
        !urlHost.canParseAsIpAddress()
    }

    private fun pathMatch(

  /** Returns an address that's without an SSL socket factory or hostname verifier.  */
  fun newAddress(
    uriHost: String = this.uriHost,
    uriPort: Int = this.uriPort,
    proxy: Proxy? = null,
    proxySelector: ProxySelector = this.proxySelector,
  ): Address {
    return Address(
      uriHost = uriHost,
      uriPort = uriPort,
      dns = dns,
      socketFactory = SocketFactory.getDefault(),

 * address also includes the SSL socket factory, hostname verifier, and certificate pinner.
 *
 * HTTP requests that share the same [Address] may also share the same [Connection].
 */
class Address(
  uriHost: String,
  uriPort: Int,
  /** Returns the service that will be used to resolve IP addresses for hostnames. */
  @get:JvmName("dns") val dns: Dns,
  /** Returns the socket factory for new connections. */

import okhttp3.internal.http.RecordingProxySelector
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.Test

class AddressTest {
  private val factory =
    TestValueFactory().apply {
      uriHost = "example.com"
      uriPort = 80
    }

  @AfterEach fun tearDown() {
    factory.close()
  }

  @Test fun equalsAndHashcode() {
    val a = factory.newAddress()
    val b = factory.newAddress()

func (c *ConfigWriter) PrintRouteSummary(filter RouteFilter) error {
	w, routes, err := c.setupRouteConfigWriter()
	if err != nil {
		return err
	}
	if filter.Verbose {
		fmt.Fprintln(w, "NAME\tVHOST NAME\tDOMAINS\tMATCH\tVIRTUAL SERVICE")
	} else {
		fmt.Fprintln(w, "NAME\tVIRTUAL HOSTS")
	}
	for _, route := range routes {
		if filter.Verify(route) {
			if includeConfigType {

    if (url.isHttps) {
      useSslSocketFactory = sslSocketFactory
      useHostnameVerifier = hostnameVerifier
      useCertificatePinner = certificatePinner
    }

    return Address(
      uriHost = url.host,
      uriPort = url.port,
      dns = dns,
      socketFactory = socketFactory,
      sslSocketFactory = useSslSocketFactory,
      hostnameVerifier = useHostnameVerifier,

- Added a check on a user attempting to create a static pod via the `kubelet` without specifying a name. They will now get a visible validation error. ([#119522](https://github.com/kubernetes/kubernetes/pull/119522), [@YTGhost](https://github.com/YTGhost))