override fun delete(
    path: Path,
    mustExist: Boolean,
  ) {
    log("delete($path)")

    super.delete(path, mustExist)
  }

  override fun sink(
    path: Path,
    mustCreate: Boolean,
  ): Sink {
    log("sink($path)")

    return super.sink(path, mustCreate)
  }

  override fun source(file: Path): Source {
    log("source($file)")

    return super.source(file)
  }

package mockwebserver3.internal

import okio.Buffer
import okio.Sink

/**
 * A sink that sleeps [periodDelayNanos] every [bytesPerPeriod] bytes. Unlike [okio.Throttler],
 * this permits any interval to be used.
 */
internal class ThrottledSink(
  private val delegate: Sink,
  private val bytesPerPeriod: Long,
  private val periodDelayNanos: Long,
) : Sink by delegate {
  private var bytesWrittenSinceLastDelay = 0L

  /**
   * Returns the number of bytes that will be written to sink in a call to [writeTo],
   * or -1 if that count is unknown.
   */
  @Throws(IOException::class)
  open fun contentLength(): Long = commonContentLength()

  /** Writes the content of this request to [sink]. */
  @Throws(IOException::class)
  abstract fun writeTo(sink: BufferedSink)

  /**

import okhttp3.MediaType
import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.curl.Main
import okhttp3.internal.http.StatusLine
import okio.sink

internal fun Main.commonCreateRequest(): Request {
  val request = Request.Builder()

  val requestMethod = method ?: if (data != null) "POST" else "GET"

  val url = url ?: throw IOException("No url provided")

    val requestBody =
      object : RequestBody() {
        override fun contentType() = MEDIA_TYPE_MARKDOWN

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("Numbers\n")
          sink.writeUtf8("-------\n")
          for (i in 2..997) {
            sink.writeUtf8(String.format(" * $i = ${factor(i)}\n"))
          }
        }

        private fun factor(n: Int): String {

    randomAccessFile!!.getChannel().force(false)
    val source = file!!.source().buffer()
    return source.readByteString()
  }

  private fun write(data: ByteString) {
    val sink = file!!.sink().buffer()
    sink.write(data)
    sink.close()
  }

  private fun transfer(
    fromAddress: InetAddress,
    toAddress: InetAddress,
    source: BufferedSource,
    sink: BufferedSink,
  ) {
    executor.execute {
      val name = "SocksProxy $fromAddress to $toAddress"
      threadName(name) {
        val buffer = Buffer()
        try {
          sink.use {
            source.use {
              while (true) {
                val byteCount = source.read(buffer, 8192L)

        override fun contentType(): MediaType? {
          return null
        }

        override fun writeTo(sink: BufferedSink) {
          sink.writeUtf8("abc")
          sink.flush()
          makeFailingCall()
          sink.writeUtf8("def")
          sink.flush()
        }
      }
    val call =
      client.newCall(
        Request(
          url = server.url("/"),

  override fun contentLength(): Long = writeOrCountBytes(null, true)

  @Throws(IOException::class)
  override fun writeTo(sink: BufferedSink) {
    writeOrCountBytes(sink, false)
  }

  /**
   * Either writes this request to [sink] or measures its content length. We have one method
   * do double-duty to make sure the counting and content are consistent, particularly when it comes

      }

      override fun writeTo(sink: BufferedSink) {
        sink.writeUtf8("<el")
        sink.flush()
        throw IOException("failed to stream the XML")
      }
    }

    class ValidRequestBody : RequestBody() {
      override fun contentType(): MediaType {
        return "application/xml".toMediaType()
      }

      override fun writeTo(sink: BufferedSink) {
        sink.writeUtf8("<element/>")