*  Fix: Immediately update the connection's flow control window instead of waiting for the
    receiving stream to process it.

    This change may increase OkHttp's memory use for applications that make many concurrent HTTP
    calls and that can receive data faster than they can process it. Previously, OkHttp limited
    HTTP/2 to 16 MiB of unacknowledged data per connection. With this fix there is a limit of 16 MiB

    request: Request,
    newRoutePlanner: Boolean,
    chain: RealInterceptorChain,
  ) {
    check(interceptorScopedExchange == null)

    this.withLock {
      check(!responseBodyOpen) {
        "cannot make a new request because the previous response is still open: " +
          "please call response.close()"
      }
      check(!requestBodyOpen)
    }

    if (newRoutePlanner) {
      val routePlanner =

    val adapter = Adapters.NULL.withTag(tagClass = DerHeader.TAG_CLASS_PRIVATE, tag = 65_000L)
    assertThat(adapter.toDer(null)).isEqualTo(bytes)
    assertThat(adapter.fromDer(bytes)).isNull()
  }

  /** Make the claimed length of a nested object larger than the enclosing object. */
  @Test fun `large object inside small object`() {
    val bytes = "301b300d06092a864886f70d010101050003847fffffff000504030201".decodeHex()

      }
    }
  }

  /**
   * To make an HTTPS connection over an HTTP proxy, send an unencrypted CONNECT request to create
   * the proxy connection. This may need to be retried if the proxy requires authorization.
   */
  @Throws(IOException::class)
  private fun createTunnel(): Request? {
    var nextRequest = tunnelRequest!!
    // Make an SSL Tunnel on the first message pair of each SSL + proxy connection.

 *
 * ## Warning: Certificate Pinning is Dangerous!
 *
 * Pinning certificates limits your server team's abilities to update their TLS certificates. By
 * pinning certificates, you take on additional operational complexity and limit your ability to
 * migrate between certificate authorities. Do not use certificate pinning without the blessing of
 * your server's TLS administrator!
 *

    val data = ByteArray(1024 * 1024)
    var i = 0
    while (i < 1024) {
      try {
        out.write(data)
        out.flush()
        if (i == 513) {
          // pause slightly after halfway to make result more predictable
          Thread.sleep(100)
        }
      } catch (e: IOException) {
        break
      }
      i++
    }
    // Halfway +/- 0.5%

import org.junit.jupiter.api.Test
import org.junit.jupiter.api.extension.RegisterExtension
import org.opentest4j.TestAbortedException

/**
 * Run with "./gradlew :android-test:connectedCheck -PandroidBuild=true" and make sure ANDROID_SDK_ROOT is set.
 */

@Tag("Slow")
class OkHttpTest {
  @Suppress("RedundantVisibilityModifier")
  @JvmField
  @RegisterExtension
  public val platform = PlatformRule()

  private var contextSwitchCount = 0

  /** Guarded by [TaskRunner.lock]. */
  private var activeThreads = 0

  /** A task runner that posts tasks to this fake. Tasks won't be executed until requested. */
  val taskRunner: TaskRunner =
    TaskRunner(
      object : TaskRunner.Backend {
        override fun execute(
          taskRunner: TaskRunner,
          runnable: Runnable,

    val request =
      Request.Builder()
        .url(server.url("/"))
        .build()
    val response = client.newCall(request).execute()
    assertThat("b").isEqualTo(response.body.string())
  }

  /** Make sure interceptors can interact with the OkHttp client.  */
  @Test
  fun interceptorMakesAnUnrelatedRequest() {
    server.enqueue(MockResponse.Builder().body("a").build()) // Fetched by interceptor.

   * connect, and it sets up a same-connection retry with [ErrorCode.REFUSED_STREAM].
   *
   * https://github.com/square/okhttp/pull/7190
   */
  @Test
  fun preferCallConnectionOverDeferredConnection() {
    // Make sure we have enough connection options to permit retries.
    dnsResults =
      listOf(
        localhostIpv4,
        localhostIpv6,
        TestUtil.UNREACHABLE_ADDRESS_IPV4.address,
      )