}

    fun allEnabledCipherSuites() =
      apply {
        require(tls) { "no cipher suites for cleartext connections" }
        this.cipherSuites = null
      }

    fun cipherSuites(vararg cipherSuites: CipherSuite): Builder =
      apply {
        require(tls) { "no cipher suites for cleartext connections" }

    checkNotNull(keyFunction);
    checkNotNull(valueFunction);
    return Collector.of(
        ImmutableMap.Builder<K, V>::new,
        (builder, input) -> builder.put(keyFunction.apply(input), valueFunction.apply(input)),
        ImmutableMap.Builder::combine,
        ImmutableMap.Builder::buildOrThrow);
  }

  static <T extends @Nullable Object, K, V> Collector<T, ?, ImmutableMap<K, V>> toImmutableMap(

          @Override
          public Arithmetic apply(Arithmetic arithmetic) {
            return new ForwardingArithmetic(arithmetic);
          }
        });
    tester.testForwarding(
        ParameterTypesDifferent.class,
        new Function<ParameterTypesDifferent, ParameterTypesDifferent>() {
          @Override
          public ParameterTypesDifferent apply(ParameterTypesDifferent delegate) {

    T instance = generator.newFreshProxy(interfaceType);
    new EqualsTester()
        .addEqualityGroup(wrapperFunction.apply(instance), wrapperFunction.apply(instance))
        .addEqualityGroup(wrapperFunction.apply(generator.newFreshProxy(interfaceType)))
        // TODO: add an overload to EqualsTester to print custom error message?
        .testEquals();
  }

        private
        fun newSimpleDateFormatUTC(pattern: String) = SimpleDateFormat(pattern).apply {
            timeZone = TimeZone.getTimeZone("UTC")
        }

        fun readBuildReceiptFromString(buildReceipt: String) =
            Properties().apply { load(buildReceipt.reader()) }

        const val buildReceiptFileName = "build-receipt.properties"

    socketFactory[ipv6] = server1.inetSocketAddress
    socketFactory[ipv4] = server2.inetSocketAddress

    client =
      client.newBuilder()
        .fastFallback(false)
        .apply {
          retryOnConnectionFailure = false
        }
        .build()

    executeSynchronously(request)
      .assertFailureMatches("stream was reset: REFUSED_STREAM")

    assertThat(retryTlsHandshake(exception)).isFalse()
  }

  @Test fun nonRetryableSSLHandshakeException() {
    val exception =
      SSLHandshakeException("Certificate handshake exception").apply {
        initCause(CertificateException())
      }
    assertThat(retryTlsHandshake(exception)).isFalse()
  }

  @Test fun retryableSSLHandshakeException() {

                    Object key = getDependencyKey().apply(dependency);
                    dependencies.put(key, dependency);
                }

                boolean modified = false;
                for (Dependency managedDependency : dependencyManagement.getDependencies()) {
                    Object key = getDependencyKey().apply(managedDependency);
                    Dependency dependency = dependencies.get(key);

     */
    fun scheme(scheme: String) =
      apply {
        when {
          scheme.equals("http", ignoreCase = true) -> this.scheme = "http"
          scheme.equals("https", ignoreCase = true) -> this.scheme = "https"
          else -> throw IllegalArgumentException("unexpected scheme: $scheme")
        }
      }

    fun username(username: String) =
      apply {

     */
    fun cookieJar(cookieJar: CookieJar) =
      apply {
        this.cookieJar = cookieJar
      }

    /** Sets the response cache to be used to read and write cached responses. */
    fun cache(cache: Cache?) =
      apply {
        this.cache = cache
      }

    internal fun taskRunner(taskRunner: TaskRunner) =
      apply {
        this.taskRunner = taskRunner
      }

    /**