builder.put(k3, v3);
    builder.put(k4, v4);
    builder.put(k5, v5);
    return builder.build();
  }

  // looking for of() with > 5 entries? Use the builder instead.

  /** Returns a new {@link Builder}. */
  public static <K, V> Builder<K, V> builder() {
    return new Builder<>();
  }

  /**
   * Returns a new builder with a hint for how many distinct keys are expected to be added. The

// GetValueWithQuorum returns the first key which occurs >= quorum number of times.
func (c counterMap[T]) GetValueWithQuorum(quorum int) (T, bool) {
	var zero T
	for x, count := range c {
		if count >= quorum {
			return x, true
		}
	}
	return zero, false
}

// figure out the most commonVersions across disk that satisfies
// the 'writeQuorum' this function returns "" if quorum cannot

   * {@link Set}, instead of the {@link java.util.Collection} specified in the {@link Multimap}
   * interface.
   */
  @Override
  Set<V> get(@ParametricNullness K key);

  /**
   * {@inheritDoc}
   *
   * <p>Because a {@code SetMultimap} has unique values for a given key, this method returns a

   * {@link Set}, instead of the {@link java.util.Collection} specified in the {@link Multimap}
   * interface.
   */
  @Override
  Set<V> get(@ParametricNullness K key);

  /**
   * {@inheritDoc}
   *
   * <p>Because a {@code SetMultimap} has unique values for a given key, this method returns a

     * @return this instance
     */
    public Maps<K, V> $(final K key, final V value) {
        map.put(key, value);
        return this;
    }

    /**
     * Returns the <code>Map</code>.
     *
     * @return the <code>Map</code> with the added keys and values
     */
    public Map<K, V> $() {
        return map;
    }

    switch (elements.length) {
      case 0:
        return of();
      case 1:
        return of(elements[0]);
      default:
        return construct(elements.length, elements.clone());
    }
  }

  ImmutableSet() {}

  /** Returns {@code true} if the {@code hashCode()} method runs quickly. */
  boolean isHashCodeFast() {
    return false;
  }

  @Override

interface ExchangeCodec {
  /** The connection or CONNECT tunnel that owns this codec. */
  val carrier: Carrier

  /** Returns true if the response body and (possibly empty) trailers have been received. */
  val isResponseComplete: Boolean

  /** The socket that carries this exchange. */
  val socket: Socket

  /** Returns an output stream where the request body can be streamed. */
  @Throws(IOException::class)
  fun createRequestBody(

    /** Returns the file the process writes its bound ports to. Defaults to "ports" inside baseDir. */
    @Internal
    protected File getPortsFile() {
        return new File(baseDir, 'ports')
    }

    /** Returns an address and port suitable for a uri to connect to this node over http */
    @Internal
    String getAddressAndPort() {
        return portsFile.readLines("UTF-8").get(0)
    }

		return endpoint.Path
	}

	return endpoint.URL.String()
}

// Type - returns type of endpoint.
func (endpoint Endpoint) Type() EndpointType {
	if endpoint.Host == "" {
		return PathEndpointType
	}

	return URLEndpointType
}

// HTTPS - returns true if secure for URLEndpointType.
func (endpoint Endpoint) HTTPS() bool {
	return endpoint.Scheme == "https"
}

    val c1 = factory.newConnection(pool, routeA1, 50L)

    // Running at time 50, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(50L)).isEqualTo(100L)
    assertThat(pool.connectionCount()).isEqualTo(1)
    assertThat(c1.socket().isClosed).isFalse()

    // Running at time 60, the pool returns that nothing can be evicted until time 150.
    assertThat(pool.closeConnections(60L)).isEqualTo(90L)