return true // ALPN is supported.
      } else if (methodName == "unsupported" && Void.TYPE == returnType) {
        this.unsupported = true // Peer doesn't support ALPN.
        return null
      } else if (methodName == "protocols" && callArgs.isEmpty()) {
        return protocols // Client advertises these protocols.
      } else if ((methodName == "selectProtocol" || methodName == "select") &&

  fun setFaultyWrite(
    file: Path,
    faulty: Boolean,
  ) {
    if (faulty) {
      writeFaults.add(file)
    } else {
      writeFaults.remove(file)
    }
  }

  fun setFaultyDelete(
    file: Path,
    faulty: Boolean,
  ) {
    if (faulty) {
      deleteFaults.add(file)
    } else {
      deleteFaults.remove(file)
    }
  }

  fun setFaultyRename(
    file: Path,
    faulty: Boolean,

            requestBody.writeTo(bufferedRequestBody)
          } else {
            // Write the request body if the "Expect: 100-continue" expectation was met.
            val bufferedRequestBody = exchange.createRequestBody(request, false).buffer()
            requestBody.writeTo(bufferedRequestBody)
            bufferedRequestBody.close()
          }
        } else {
          exchange.noRequestBody()

        // Handles both un-configured and none selected.
        null, "" -> null
        else -> protocol
      }
    } else {
      super.getSelectedProtocol(sslSocket)
    }

  companion object {
    val isSupported: Boolean =
      try {
        // Trigger an early exception over a fatal error, prefer a RuntimeException over Error.

    if (proxy.type() == Proxy.Type.SOCKS) {
      mutableInetSocketAddresses += InetSocketAddress.createUnresolved(socketHost, socketPort)
    } else {
      val addresses =
        if (socketHost.canParseAsIpAddress()) {
          listOf(InetAddress.getByName(socketHost))
        } else {
          connectionUser.dnsStart(socketHost)

          val result = address.dns.lookup(socketHost)
          if (result.isEmpty()) {

    while (!input.exhausted()) {
      val codePoint = input.readUtf8CodePoint()
      when (val mappedCodePoint = mapping[codePoint]) {
        null -> mapResult.writeUtf8CodePoint(codePoint)
        else -> mapResult.writeUtf8(mappedCodePoint)
      }
    }

    // 2. Normalize
    // TODO.

    // 3 and 4. Check prohibited characters and bidi.
    val validateBuffer = mapResult.copy()

      // JUnit 5's APIs need java.util.function.Function and java.util.Optional from API 24.
      signature(rootProject.libs.signature.android.apilevel24) { artifact { type = "signature" } }
    } else {
      // Everything else requires Android API 21+.
      signature(rootProject.libs.signature.android.apilevel21) { artifact { type = "signature" } }
    }

    // OkHttp requires Java 8+.

    proxyType: Proxy.Type,
  ): String =
    buildString {
      append(request.method)
      append(' ')
      if (includeAuthorityInRequestLine(request, proxyType)) {
        append(request.url)
      } else {
        append(requestPath(request.url))
      }
      append(" HTTP/1.1")
    }

  /**
   * Returns true if the request line should contain the full URL with host and port (like "GET

      "Unexpected char 0x${c.charCode()} at $i in $name value" +
        (if (isSensitiveHeader(name)) "" else ": $value")
    }
  }
}

private fun Char.charCode() =
  code.toString(16).let {
    if (it.length < 2) {
      "0$it"
    } else {
      it
    }
  }

internal fun commonHeadersOf(vararg inputNamesAndValues: String): Headers {

      "localCertificates=${localCertificates.map { it.name }}}"
  }

  private val Certificate.name: String
    get() =
      when (this) {
        is X509Certificate -> subjectDN.toString()
        else -> type
      }

  companion object {
    @Throws(IOException::class)
    @JvmStatic
    @JvmName("get")
    fun SSLSession.handshake(): Handshake {
      val cipherSuite =