return responseQueue.peek() ?: failFastResponse ?: super.peek()
  }

  open fun enqueueResponse(response: MockResponse) {
    responseQueue.add(response)
  }

  open fun clear() {
    responseQueue.clear()
  }

  override fun shutdown() {
    responseQueue.add(DEAD_LETTER)
  }

  open fun setFailFast(failFast: Boolean) {
    val failFastResponse =
      if (failFast) {

 *
 * This test includes tests from [Guava's](https://code.google.com/p/guava-libraries/)
 * MediaTypeTest.
 */
open class MediaTypeTest {
  open fun MediaType.charsetName(): String? = parameter("charset")?.uppercase()

  protected open fun parse(string: String): MediaType = string.toMediaTypeOrNull()!!

  protected open fun assertInvalid(
    string: String,
    exceptionMessage: String?,
  ) {

    mockResponse = mockResponse.setChunkedBody(Buffer(), 0)
    mockResponse = mockResponse.setChunkedBody("", 0)
    var socketPolicy: SocketPolicy = mockResponse.socketPolicy
    mockResponse.socketPolicy = SocketPolicy.KEEP_OPEN
    var http2ErrorCode: Int = mockResponse.http2ErrorCode
    mockResponse.http2ErrorCode = 0
    mockResponse = mockResponse.throttleBody(0L, 0L, TimeUnit.SECONDS)

sealed class CallEvent {
  abstract val timestampNs: Long
  abstract val call: Call

  val name: String
    get() = javaClass.simpleName

  /** Returns if the event closes this event, or null if this is no open event. */
  open fun closes(event: CallEvent): Boolean? = null

  data class ProxySelectStart(
    override val timestampNs: Long,
    override val call: Call,
    val url: HttpUrl,
  ) : CallEvent()

 *
 *  * **Connecting:** the initial state of each web socket. Messages may be enqueued but they won't
 *    be transmitted until the web socket is open.
 *
 *  * **Open:** the web socket has been accepted by the remote peer and is fully operational.
 *    Messages in either direction are enqueued for immediate transmission.
 *

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import okio.BufferedSource

open class ForwardingResponseBody(delegate: ResponseBody?) : ResponseBody() {
  private val delegate: ResponseBody

  fun delegate(): ResponseBody {
    return delegate
  }

  override fun contentType(): MediaType? {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3

import java.io.IOException
import okio.BufferedSink

open class ForwardingRequestBody(delegate: RequestBody?) : RequestBody() {
  private val delegate: RequestBody

  fun delegate(): RequestBody {
    return delegate
  }

  override fun contentType(): MediaType? {

 * limitations under the License.
 */
package okhttp3.internal.http2

import assertk.fail
import okio.BufferedSource
import okio.ByteString

internal open class BaseTestHandler : Http2Reader.Handler {
  override fun data(
    inFinished: Boolean,
    streamId: Int,
    source: BufferedSource,
    length: Int,
  ) {
    fail("")
  }

  override fun headers(

/*
 * Copyright (C) 2012 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,

import javax.net.ssl.SSLSocket
import javax.net.ssl.SSLSocketFactory
import javax.net.ssl.X509TrustManager
import okhttp3.Protocol
import okhttp3.internal.SuppressSignatureCheck

/** OpenJDK 9+. */
open class Jdk9Platform : Platform() {
  @SuppressSignatureCheck
  override fun configureTlsExtensions(
    sslSocket: SSLSocket,
    hostname: String?,
    protocols: List<@JvmSuppressWildcards Protocol>,
  ) {