@Throws(EOFException::class)
private fun Buffer.readChallengeHeader(result: MutableList<Challenge>) {
  var peek: String? = null

  while (true) {
    // Read a scheme name for this challenge if we don't have one already.
    if (peek == null) {
      skipCommasAndWhitespace()
      peek = readToken()
      if (peek == null) return
    }

    val schemeName = peek

    // Read a token68, a sequence of parameters, or nothing.

    override fun dispatch(request: mockwebserver3.RecordedRequest): mockwebserver3.MockResponse {
      return delegate.dispatch(request.unwrap()).wrap()
    }

    override fun peek(): mockwebserver3.MockResponse {
      return delegate.peek().wrap()
    }

    override fun shutdown() {
      delegate.shutdown()
    }
  }
}

internal fun MockResponse.wrap(): mockwebserver3.MockResponse {

  @Throws(InterruptedException::class)
  override fun dispatch(request: RecordedRequest): MockResponse {
    throw UnsupportedOperationException("unexpected call")
  }

  override fun peek(): MockResponse {
    throw UnsupportedOperationException("unexpected call")
  }

  fun enqueueResponse(response: MockResponse) {
    delegate.enqueueResponse(response.wrap())
  }

  override fun shutdown() {

 * limitations under the License.
 */
package okhttp3.mockwebserver

abstract class Dispatcher {
  @Throws(InterruptedException::class)
  abstract fun dispatch(request: RecordedRequest): MockResponse

  open fun peek(): MockResponse {
    return MockResponse().apply { this.socketPolicy = SocketPolicy.KEEP_OPEN }
  }

  open fun shutdown() {}

   * can return other values to test HTTP edge cases, such as unhappy socket policies or throttled
   * request bodies.
   */
  open fun peek(): MockResponse {
    return MockResponse(socketPolicy = KeepOpen)
  }

  /**
   * Release any resources held by this dispatcher. Any requests that are currently being dispatched

  name: String,
  defaultValue: String?,
): String? = headers[name] ?: defaultValue

@Throws(IOException::class)
fun Response.commonPeekBody(byteCount: Long): ResponseBody {
  val peeked = body.source().peek()
  val buffer = Buffer()
  peeked.request(byteCount)
  buffer.write(peeked, minOf(byteCount, peeked.buffer.size))
  return buffer.asResponseBody(body.contentType(), buffer.size)
}

    // other threads waiting on take() will also return.
    if (result == DEAD_LETTER) responseQueue.add(DEAD_LETTER)

    return result
  }

  override fun peek(): MockResponse {
    return responseQueue.peek() ?: failFastResponse ?: super.peek()
  }

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

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

  @Test @Ignore
  fun dispatcherFromMockWebServer() {
    val dispatcher =
      object : Dispatcher() {
        override fun dispatch(request: RecordedRequest): MockResponse = TODO()

        override fun peek(): MockResponse = TODO()

        override fun shutdown() = TODO()
      }
  }

  @Test @Ignore
  fun mockResponse() {
    var mockResponse: MockResponse = MockResponse()

      sinkBuffer.write(maskKey)

      if (length > 0) {
        val payloadStart = sinkBuffer.size
        sinkBuffer.write(payload)

        sinkBuffer.readAndWriteUnsafe(maskCursor!!)
        maskCursor.seek(payloadStart)
        toggleMask(maskCursor, maskKey)
        maskCursor.close()
      }
    } else {
      sinkBuffer.writeByte(b1)
      sinkBuffer.write(payload)
    }

    sink.flush()
  }