* [reader]. For example, if the reader's peeked tag isn't readable by this adapter, it may return
   * a default value.
   *
   * If this does read a value, it starts with the tag and length, and reads an entire value,
   * including any potential composed values.
   *
   * If there's nothing to read and no default value, this will throw an exception.
   */

          }
        }
      }

      val startNs = System.nanoTime()
      val response: Response
      try {
        response = chain.proceed(request)
      } catch (e: Exception) {
        logger.log("<-- HTTP FAILED: $e")
        throw e
      }

      val tookMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startNs)

      val responseBody = response.body!!

## Version 4.6.0

_2020-04-28_

 *  Fix: Follow HTTP 307 and 308 redirects on methods other than GET and POST. We're reluctant to
    change OkHttp's behavior in handling common HTTP status codes, but this fix is overdue! The new
    behavior is now consistent with [RFC 7231][rfc_7231_647], which is newer than OkHttp itself.
    If you want this update with the old behavior use [this interceptor][legacy_interceptor].

  /**
   * Starts the server on the loopback interface for the given port.
   *
   * @param port the port to listen to, or 0 for any available port. Automated tests should always
   * use port 0 to avoid flakiness when a specific port is unavailable.
   */
  @Throws(IOException::class)
  @JvmOverloads
  fun start(port: Int = 0) = start(InetAddress.getByName("localhost"), port)

  /**

      val rangeLimit =
        when {
          r + 1 < rangesOffsets.size -> rangesOffsets[r + 1] * 4
          else -> rangesOffsets.size * 4
        }

      // Confirm this range starts with byte 0.
      assertThat(compactTable.ranges[rangePos].code).isEqualTo(0)

      // Confirm this range's index byte is increasing.
      val rangeStarts = mutableListOf<Int>()

        .body("A")
        .status("HTTP/1.1 200 A-OK")
        .build(),
    )
    server.enqueue(
      MockResponse.Builder()
        .code(HttpURLConnection.HTTP_NOT_MODIFIED)
        .build(),
    )

    // scenario 2: condition fails
    server.enqueue(
      response.newBuilder()
        .body("B")
        .status("HTTP/1.1 200 B-OK")
        .build(),
    )

    delegate.enqueue(response.wrap())
  }

  @Throws(IOException::class)
  @JvmOverloads
  fun start(port: Int = 0) {
    started = true
    delegate.start(port)
  }

  @Throws(IOException::class)
  fun start(
    inetAddress: InetAddress,
    port: Int,
  ) {
    started = true
    delegate.start(inetAddress, port)
  }

  @Synchronized
  @Throws(IOException::class)
  fun shutdown() {

    }
    assertThat(taskFaker.executeCallCount).isEqualTo(1)

    // Running the red task starts another thread, so the two can run in parallel.
    taskFaker.runNextTask()
    assertThat(log).containsExactly("red:starting@0")
    assertThat(taskFaker.executeCallCount).isEqualTo(2)

    // Next the blue task starts.
    taskFaker.runNextTask()
    assertThat(log).containsExactly(
      "red:starting@0",

  internal val eventListener: EventListener,
  internal val finder: ExchangeFinder,
  private val codec: ExchangeCodec,
) {
  /** True if the request body need not complete before the response body starts. */
  internal var isDuplex: Boolean = false
    private set

  /** True if there was an exception on the connection to the peer. */
  internal var hasFailure: Boolean = false
    private set

    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    val request = Request(server.url("/"))
    val response = client.newCall(request).execute()
    response.body.close()

    // This client shares a connection pool but has a different SSL socket factory.
    val handshakeCertificates2 = HandshakeCertificates.Builder().build()
    val anotherClient =
      client.newBuilder()
        .sslSocketFactory(