// This explicit check avoids activating in Android Studio with Android specific classes
    // available when running plugins inside the IDE.
    val isAndroid: Boolean
      get() = "Dalvik" == System.getProperty("java.vm.name")

    private val isConscryptPreferred: Boolean
      get() {
        val preferredProvider = Security.getProviders()[0].name

    of our effort to remove the okhttp-tls module's dependency on Bouncy Castle. We think Bouncy
    Castle is great! But it's a large dependency (6.5 MiB) and its security provider feature
    impacts VM-wide behavior.

 *  New: Reduce contention for applications that make a very high number of concurrent requests.
    Previously OkHttp used its connection pool as a lock when making changes to connections and

  private fun buildServerSslSocketFactory(): SSLSocketFactory {
    // The test uses JDK default SSL Context instead of the Platform provided one
    // as Conscrypt seems to have some differences, we only want to test client side here.
    return try {
      val keyManager =
        newKeyManager(
          null,
          serverCert,
          serverIntermediateCa.certificate,
        )
      val trustManager =

    val response = client.newCall(request).execute()

    response.use {
      assertEquals(200, response.code)
    }
  }

  @Test
  @Disabled("cleartext required for additional okhttp wide tests")
  fun testHttpRequestBlocked() {
    assumeTrue(Build.VERSION.SDK_INT >= 23)

    val request = Request.Builder().url("http://squareup.com/robots.txt").build()

    try {

 *
 * The task runner is also responsible for releasing held threads when the library is unloaded.
 * This is for the benefit of container environments that implement code unloading.
 *
 * Most applications should share a process-wide [TaskRunner] and use queues for per-client work.
 */
class TaskRunner(
  val backend: Backend,
  internal val logger: Logger = TaskRunner.logger,
) {
  val lock: ReentrantLock = ReentrantLock()

    // we should try the next route (if there is one).
    if (e is InterruptedIOException) {
      return e is SocketTimeoutException && !requestSendStarted
    }

    // Look for known client-side or negotiation errors that are unlikely to be fixed by trying
    // again with a different route.
    if (e is SSLHandshakeException) {
      // If the problem was a CertificateException from the X509TrustManager,

    address. Use this to proactively open HTTP connections.

    Connections opened to fulfill this policy are subject to the connection pool's
    `keepAliveDuration` but do not count against the pool-wide `maxIdleConnections` limit.

    This feature increases the client's traffic and the load on the server. Talking to your server's
    operators before adopting it.

  internal fun removeStream(streamId: Int): Http2Stream? {
    this.withLock {
      val stream = streams.remove(streamId)

      // The removed stream may be blocked on a connection-wide window update.
      condition.signalAll()

      return stream
    }
  }

  internal fun updateConnectionFlowControl(read: Long) {
    this.withLock {
      readBytes.update(total = read)

   */
  inner class FramingSource internal constructor(
    /** Maximum number of bytes to buffer before reporting a flow control error. */
    private val maxByteCount: Long,
    /**
     * True if either side has cleanly shut down this stream. We will receive no more bytes beyond
     * those already in the buffer.
     */
    internal var finished: Boolean,
  ) : Source {

    checkPublicSuffix("kyoto.jp", null)
    checkPublicSuffix("test.kyoto.jp", "test.kyoto.jp")
    checkPublicSuffix("ide.kyoto.jp", null)
    checkPublicSuffix("b.ide.kyoto.jp", "b.ide.kyoto.jp")
    checkPublicSuffix("a.b.ide.kyoto.jp", "b.ide.kyoto.jp")
    checkPublicSuffix("c.kobe.jp", null)
    checkPublicSuffix("b.c.kobe.jp", "b.c.kobe.jp")
    checkPublicSuffix("a.b.c.kobe.jp", "b.c.kobe.jp")