testing everything. You can even copy & paste HTTP responses from your real web
server to create representative test cases. Or test that your code survives in
awkward-to-reproduce situations like 500 errors or slow-loading responses.


### Example

Use MockWebServer the same way that you use mocking frameworks like
[Mockito](https://github.com/mockito/mockito):

1. Script the mocks.
2. Run application code.

    assertThat(formatDuration(-2_500_000_000L)).isEqualTo(" -3 s ")
    assertThat(formatDuration(-2_499_999_999L)).isEqualTo(" -2 s ")
    assertThat(formatDuration(-1_500_000_000L)).isEqualTo(" -2 s ")
    assertThat(formatDuration(-1_499_999_999L)).isEqualTo(" -1 s ")
    assertThat(formatDuration(-1_000_000_000L)).isEqualTo(" -1 s ")
    assertThat(formatDuration(  -999_500_000L)).isEqualTo(" -1 s ")

    assertThat(server.takeRequest().sequenceNumber).isEqualTo(0)

    // Give the server time to enact the socket policy if it's one that could happen after the
    // client has received the response.
    Thread.sleep(500)
    val response2 = getResponse(newRequest("/b"))
    response1.body.source().timeout().timeout(100, TimeUnit.MILLISECONDS)
    assertContent("This comes after a busted connection", response2)

  }

  @Test
  fun timeoutWritingRequest() {
    server.enqueue(MockResponse())
    val request =
      Request.Builder()
        .url(server.url("/"))
        .post(sleepingRequestBody(500))
        .build()
    val call = client.newCall(request)
    call.timeout().timeout(250, TimeUnit.MILLISECONDS)
    assertFailsWith<IOException> {
      call.execute()
    }.also { expected ->

  private val serverListener = WebSocketRecorder("server")
  private val random = Random(0)
  private var client =
    clientTestRule.newClientBuilder()
      .writeTimeout(Duration.ofMillis(500))
      .readTimeout(Duration.ofMillis(500))
      .addInterceptor(
        Interceptor { chain: Interceptor.Chain ->
          val response = chain.proceed(chain.request())
          // Ensure application interceptors never see a null body.

    val future1 = executor.submit(sourceReader(relay.newSource()))
    val future2 = executor.submit(sourceReader(relay.newSource()))
    Thread.sleep(500)
    sink.writeUtf8("abcdefghij")
    Thread.sleep(500)
    sink.writeUtf8("klmnopqrst")
    sink.close()
    assertThat<ByteString>(future1.get())
      .isEqualTo("abcdefghijklmnopqrst".encodeUtf8())
    assertThat<ByteString>(future2.get())

        .throttleBody((64 * 1024).toLong(), 125, TimeUnit.MILLISECONDS),
    ) // 500 Kbps
    server.start()
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .build(),
      )
    val response = call.execute()
    interruptLater(500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)

   * 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)

    client.listener.assertFailure(IOException::class.java, "source is closed")
    assertThat(client.closed).isTrue()
  }

  @Test
  fun pingOnInterval() {
    client.initWebSocket(random, pingIntervalMillis = 500)
    taskFaker.advanceUntil(ns(500L))
    server.processNextFrame() // Ping.
    client.processNextFrame() // Pong.
    taskFaker.advanceUntil(ns(1000L))
    server.processNextFrame() // Ping.

  fun pingsTransmitted(
    protocol: Protocol,
    mockWebServer: MockWebServer,
  ) {
    setUp(protocol, mockWebServer)
    // Ping every 500 ms, starting at 500 ms.
    client =
      client.newBuilder()
        .pingInterval(Duration.ofMillis(500))
        .build()

    // Delay the response to give 1 ping enough time to be sent and replied to.
    server.enqueue(
      MockResponse.Builder()