delegate: ResponseBody?,
) : ResponseBody() {
  private val delegate: ResponseBody

  fun delegate(): ResponseBody = delegate

  override fun contentType(): MediaType? = delegate.contentType()

  override fun contentLength(): Long = delegate.contentLength()

  override fun source(): BufferedSource = delegate.source()

  override fun toString(): String = javaClass.simpleName + "(" + delegate.toString() + ")"

  init {

  val connection: RealConnection,
) : RoutePlanner.Plan {
  override val isReady = true

  override fun connectTcp() = error("already connected")

  override fun connectTlsEtc() = error("already connected")

  override fun handleSuccess() = connection

  override fun cancel() = error("unexpected cancel")

  override fun retry() = error("unexpected retry")

  private val configuredLoggers = CopyOnWriteArraySet<Logger>()

  fun enableHttp2() = enable(Http2::class)

  fun enableTaskRunner() = enable(TaskRunner::class)

  fun logHandler() =
    ConsoleHandler().apply {
      level = Level.FINE
      formatter =
        object : SimpleFormatter() {
          override fun format(record: LogRecord) = String.format("[%1\$tF %1\$tT] %2\$s %n", record.millis, record.message)

  val credential: String?,
  val scheme: String?,
) : Authenticator {
  val responses = mutableListOf<Response>()
  val routes = mutableListOf<Route>()

  fun onlyResponse() = responses.single()

  fun onlyRoute() = routes.single()

  @Throws(IOException::class)
  override fun authenticate(
    route: Route?,
    response: Response,
  ): Request? {
    if (route == null) throw NullPointerException("route == null")

 */
package okhttp3.mockwebserver

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

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

  open fun shutdown() {}

        }.build()
    threadToCancel = Thread.currentThread()
  }

  @Test
  fun cancelWritingRequestBody() {
    server.enqueue(MockResponse())
    val call =
      client.newCall(
        Request(
          url = server.url("/"),
          body =
            object : RequestBody() {
              override fun contentType(): MediaType? = null

              @Throws(
                IOException::class,

      .protocols(listOf(Protocol.HTTP_2, Protocol.HTTP_1_1))
      .eventListener(eventRecorder.eventListener)
      .build()

  @BeforeEach
  fun setUp() {
    server.protocols = bootstrapClient.protocols
    dns = buildLocalhost(bootstrapClient, false)
  }

  @Test
  fun getOne() {
    server.enqueue(
      dnsResponse(
        "0000818000010003000000000567726170680866616365626f6f6b03636f6d0000010001c00c000500010" +

        }
      }

    fun matchesCertificate(certificate: X509Certificate): Boolean =
      when (hashAlgorithm) {
        "sha256" -> hash == certificate.sha256Hash()
        "sha1" -> hash == certificate.sha1Hash()
        else -> false
      }

    override fun toString(): String = "$hashAlgorithm/${hash.base64()}"

    override fun equals(other: Any?): Boolean {

@Isolated
@SdkSuppress(minSdkVersion = 28)
class StrictModeTest {
  private val violations = mutableListOf<Violation>()

  @AfterEach
  fun cleanup() {
    StrictMode.setThreadPolicy(
      ThreadPolicy
        .Builder()
        .permitAll()
        .build(),
    )
  }

  @Test
  fun testInit() {
    Platform.resetForTests()

    applyStrictMode()

    // Not currently safe

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {
          sink.writeUtf8("a".repeat(byteCount.toInt()))
          return byteCount
        }

        override fun close() {
        }

        override fun timeout() = Timeout.NONE
      }

    assertThat(unlimitedSource.buffer().isProbablyUtf8(1L)).isTrue()