.byteCount(),
    ).isEqualTo(10L)
    assertThat(
      Headers.Builder()
        .add("abc", "def")
        .add("ghi", "jkl")
        .build()
        .byteCount(),
    ).isEqualTo(20L)
  }

  @Test fun addDate() {
    val expected = Date(0L)
    val headers =
      Headers.Builder()
        .add("testDate", expected)
        .build()
    assertThat(headers["testDate"]).isEqualTo("Thu, 01 Jan 1970 00:00:00 GMT")

    @MockWebServerInstance("A") instanceA: MockWebServer,
    @MockWebServerInstance("B") instanceB: MockWebServer,
  ) {
    assertThat(defaultInstance.port).isEqualTo(defaultInstancePort)
    assertThat(instanceA.port).isEqualTo(instanceAPort)
    assertThat(instanceB.port).isEqualTo(instanceBPort)
  }

  @Test
  fun testClient(
    defaultInstance: MockWebServer,
    @MockWebServerInstance("A") instanceA: MockWebServer,

      assertThat(response.code).isEqualTo(200)
      assertThat(EntityUtils.toString(response.entity)).isEqualTo("hello, Apache HttpClient 5.x")
    }

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isEqualTo("gzip, x-gzip, deflate")
    assertThat(recorded.headers["Connection"]).isEqualTo("keep-alive")

    assertThat(statusLine.message).isEqualTo(message)
    assertThat(statusLine.protocol).isEqualTo(Protocol.HTTP_1_1)
    assertThat(statusLine.code).isEqualTo(code)
  }

  @Test
  fun emptyMessage() {
    val version = 1
    val code = 503
    val statusLine = parse("HTTP/1.$version $code ")
    assertThat(statusLine.message).isEqualTo("")
    assertThat(statusLine.protocol).isEqualTo(Protocol.HTTP_1_1)

    assertThat(request.url.toString()).isEqualTo("http://example.com/")
    assertThat(body!!.contentType().toString())
      .isEqualTo("application/json; charset=utf-8")
    assertThat(bodyAsString(body)).isEqualTo("foo")
  }

  @Test
  fun referer() {
    val request = fromArgs("-e", "foo", "http://example.com").createRequest()
    assertThat(request.method).isEqualTo("GET")

    String result = executorService.invokeAny(tasks, Duration.ofSeconds(7));

    assertThat(result).isEqualTo("invokeAny");
    assertThat(recordedTasks).isSameInstanceAs(tasks);
    assertThat(recordedTimeUnit).isEqualTo(NANOSECONDS);
    assertThat(Duration.ofNanos(recordedTimeout)).isEqualTo(Duration.ofSeconds(7));
  }

  public void testInvokeAll() throws Exception {

                .compare(Boolean.TRUE, Boolean.TRUE)
                .result())
        .isEqualTo(0);
  }

  public void testDegenerate() {
    // kinda bogus, but who cares?
    assertThat(ComparisonChain.start().result()).isEqualTo(0);
  }

  public void testOneEqual() {
    assertThat(ComparisonChain.start().compare("a", "a").result()).isEqualTo(0);
  }

  public void testOneEqualUsingComparator() {

    // First response is still waiting.
    assertThat(firstResponseCode.get()).isEqualTo(0)
    // Second response is done.
    assertThat(secondResponseCode.get()).isEqualTo(200)
    latch.countDown()
    startsFirst.join()
    // And now it's done!
    assertThat(firstResponseCode.get()).isEqualTo(200)
    // (Still done).
    assertThat(secondResponseCode.get()).isEqualTo(200)
  }

  private fun buildRequestThread(
    path: String,

          url = server.url("/"),
          body = SlowRequestBody,
        ),
      )

    call.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("abc")
      assertThat(response.trailers()).isEqualTo(headersOf("caboose", "xyz"))
    }
  }

  @Disabled("Follow up with fix in https://github.com/square/okhttp/issues/6853")
  @Test
  fun serverDisconnectsBeforeSecondRequestHttp1() {

    assertThat(response.code).isEqualTo(200)
    assertThat(response.body.string()).isEqualTo("hello, OkHttp")

    val recorded = server.takeRequest()
    assertThat(recorded.headers["Accept"]).isEqualTo("text/plain")
    assertThat(recorded.headers["Accept-Encoding"]).isEqualTo("gzip")
    assertThat(recorded.headers["Connection"]).isEqualTo("Keep-Alive")