@Test
  fun interruptReadingResponseBody() {
    val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
    server.enqueue(
      MockResponse()
        .setBody(Buffer().write(ByteArray(responseBodySize)))
        .throttleBody((64 * 1024).toLong(), 125, TimeUnit.MILLISECONDS),
    ) // 500 Kbps
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))

    val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
    server.enqueue(
      MockResponse
        .Builder()
        .body(
          Buffer()
            .write(ByteArray(responseBodySize)),
        ).throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
        .build(),
    )
    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()
    cancelLater(call, 500)

  )
  fun getHttp2ErrorCode(): Int = http2ErrorCode

  fun setHttp2ErrorCode(http2ErrorCode: Int) =
    apply {
      this.http2ErrorCode = http2ErrorCode
    }

  fun throttleBody(
    bytesPerPeriod: Long,
    period: Long,
    unit: TimeUnit,
  ) = apply {
    throttleBytesPerPeriod = bytesPerPeriod
    throttlePeriodAmount = period
    throttlePeriodUnit = unit
  }

        .addInterceptor(interceptor1)
        .addInterceptor(interceptor2)
        .build()
    server.enqueue(
      MockResponse
        .Builder()
        .body("abc")
        .throttleBody(1, 1, TimeUnit.SECONDS)
        .build(),
    )
    val request1 =
      Request
        .Builder()
        .url(server.url("/"))
        .build()
    val call = client.newCall(request1)

testing timeouts and interactive testing.

### Java
```java
MockResponse response = new MockResponse.Builder()
    .throttleBody(1024, 1, TimeUnit.SECONDS)
    .build();
```

### Kotlin
```kotlin
val response = MockResponse.Builder()
  .throttleBody(1024, 1, TimeUnit.SECONDS)
  .build()
```

#### RecordedRequest

    SocketPolicy.NO_RESPONSE -> result.onResponseStart(SocketEffect.Stall)
    SocketPolicy.RESET_STREAM_AT_START -> result.onRequestStart(CloseStream(http2ErrorCode))
  }

  result.throttleBody(throttleBytesPerPeriod, getThrottlePeriod(MILLISECONDS), MILLISECONDS)
  result.bodyDelay(getBodyDelay(MILLISECONDS), MILLISECONDS)
  result.headersDelay(getHeadersDelay(MILLISECONDS), MILLISECONDS)
  return result.build()
}

    }
  }

  @Test
  fun failedDribbledCallEventSequence() {
    server.enqueue(
      MockResponse
        .Builder()
        .body("0123456789")
        .throttleBody(2, 100, TimeUnit.MILLISECONDS)
        .onResponseBody(CloseSocket())
        .build(),
    )
    client =
      client
        .newBuilder()
        .protocols(listOf<Protocol>(Protocol.HTTP_1_1))

    /**
     * Throttles the request reader and response writer to sleep for the given period after each
     * series of [bytesPerPeriod] bytes are transferred. Use this to simulate network behavior.
     */
    public fun throttleBody(
      bytesPerPeriod: Long,
      period: Long,
      unit: TimeUnit,
    ): Builder =
      apply {
        throttleBytesPerPeriod = bytesPerPeriod
        throttlePeriodNanos = unit.toNanos(period)

   * should yield one sleep for a total delay of 500ms.
   */
  @Test
  fun throttleRequest() {
    assumeNotWindows()
    server.enqueue(
      MockResponse()
        .throttleBody(3, 500, TimeUnit.MILLISECONDS),
    )
    val startNanos = System.nanoTime()
    val connection = server.url("/").toUrl().openConnection()
    connection.setDoOutput(true)

	public final fun socketHandler (Lmockwebserver3/SocketHandler;)Lmockwebserver3/MockResponse$Builder;
	public final fun status (Ljava/lang/String;)Lmockwebserver3/MockResponse$Builder;
	public final fun throttleBody (JJLjava/util/concurrent/TimeUnit;)Lmockwebserver3/MockResponse$Builder;
	public final fun trailers (Lokhttp3/Headers;)Lmockwebserver3/MockResponse$Builder;