assertThat(source1.readUtf8(5)).isEqualTo("abcde")
    assertThat(source2.readUtf8(5)).isEqualTo("abcde")
    assertThat(source2.readUtf8(5)).isEqualTo("fghij")
    assertThat(source1.readUtf8(5)).isEqualTo("fghij")
    assertThat(source1.exhausted()).isTrue()
    assertThat(source2.exhausted()).isTrue()
    source1.close()
    source2.close()
    assertThat(relay.isClosed).isTrue()

  @ArgumentsSource(ProtocolParamProvider::class)
  fun noDefaultContentLengthOnStreamingPost(
    protocol: Protocol,
    mockWebServer: MockWebServer,
  ) {
    setUp(protocol, mockWebServer)
    val postBytes = "FGHIJ".toByteArray()
    server.enqueue(MockResponse(body = "ABCDE"))
    val call =
      client.newCall(
        Request(
          url = server.url("/foo"),
          body =
            object : RequestBody() {

    val stream = connection.newStream(headerEntries("b", "banana"), true)

    // two outgoing writes
    val sink = stream.getSink()
    sink.write(Buffer().writeUtf8("abcde"), 5)
    sink.write(Buffer().writeUtf8("fghij"), 5)
    sink.close()

    // verify the peer received one incoming frame
    assertThat(peer.takeFrame().type).isEqualTo(Http2.TYPE_HEADERS)
    val data = peer.takeFrame()

      expectedResponseCode = 200
      server.enqueue(
        MockResponse.Builder()
          .setHeader("Cache-Control", "no-store")
          .body("FGHIJ")
          .build(),
      )
    }
    server.start()
    val request =
      Request.Builder()
        .url(server.url("/"))
        .build()
    val response = client.newCall(request).execute()

        .bodyDelay(responseBodyStartDelay, TimeUnit.MILLISECONDS)
        .throttleBody(5, responseBodyEndDelay, TimeUnit.MILLISECONDS)
        .body("fghijk")
        .build(),
    )
    call.execute().use { response ->
      assertThat(response.body.string()).isEqualTo("fghijk")
    }

    // Confirm the events occur when expected.
    listener.takeEvent(CallStart::class.java, 0L)

	}
	if _, err := buf.Read(p[0:3]); string(p[0:3]) != "def" || err != nil {
		t.Fatalf("want %q got %q, err=%v", "def", string(p[0:3]), err)
	}
	if s, err := buf.Peek(4); string(s) != "ghij" || err != nil {
		t.Fatalf("want %q got %q, err=%v", "ghij", string(s), err)
	}
	if _, err := buf.Read(p[0:]); string(p[0:]) != "ghijklmnop" || err != nil {
		t.Fatalf("want %q got %q, err=%v", "ghijklmnop", string(p[0:minReadBufferSize]), err)
	}

    server.enqueue(
      MockResponse.Builder()
        .status("HTTP/1.0 200 Fantastic")
        .addHeader("A: c")
        .addHeader("B: d")
        .addHeader("A: e")
        .chunkedBody("ABCDE\nFGHIJ\nKLMNO\nPQR", 8)
        .build(),
    )
    val request = newRequest("/")
    val response = getResponse(request)
    assertThat(response.code).isEqualTo(200)
    assertThat(response.message).isEqualTo("Fantastic")