// Read next chunk
            bytesRead = in.read(buffer);
            assertEquals(10, bytesRead, "Should read next chunk");
            assertEquals("ABCDEFGHIJ", new String(buffer, 0, bytesRead, "UTF-8"));
        }
    }

    @Test
    void testZeroByteFile() throws Exception {
        // Test handling of zero-byte files

    sink.writeUtf8("abcdefghi")
    sink.close()

    // Verify the peer received what was expected.
    val headers1 = peer.takeFrame()
    assertThat(headers1.type).isEqualTo(Http2.TYPE_HEADERS)
    val data1 = peer.takeFrame()
    assertThat(data1.type).isEqualTo(Http2.TYPE_DATA)
    assertThat(data1.streamId).isEqualTo(3)
    assertArrayEquals("abcdefghi".toByteArray(), data1.data)

import org.jspecify.annotations.NullUnmarked;

/**
 * @author ricebin
 */
@NullUnmarked
public class MultiReaderTest extends TestCase {

  public void testOnlyOneOpen() throws Exception {
    String testString = "abcdefgh";
    CharSource source = newCharSource(testString);
    int[] counter = new int[1];
    CharSource reader =
        new CharSource() {
          @Override
          public Reader openStream() throws IOException {

  }

  @Test
  public void forGraph_depthFirstPostOrder_tree() throws Exception {
    Traverser<Character> traverser = Traverser.forGraph(TREE);

    assertEqualCharNodes(traverser.depthFirstPostOrder('h'), "abcdefgh");
    assertEqualCharNodes(traverser.depthFirstPostOrder('d'), "abcd");
    assertEqualCharNodes(traverser.depthFirstPostOrder('a'), "a");
  }

  @Test

    assertThat(iterationOrder(ADAPTER.preOrderTraversal(h))).isEqualTo("hdabcegf");
  }

  public void testPostOrder() {
    assertThat(iterationOrder(ADAPTER.postOrderTraversal(h))).isEqualTo("abcdefgh");
  }

  public void testBreadthOrder() {
    assertThat(iterationOrder(ADAPTER.breadthFirstTraversal(h))).isEqualTo("hdegabcf");
  }

  public void testUsing() {

    }

    public void test_markAndReset_delegatesToUnderlying() throws IOException {
        // Test that mark() and reset() delegate to underlying stream
        byte[] data = "ABCDEFGH".getBytes();
        InputStream underlyingStream = new ByteArrayInputStream(data);
        IgnoreCloseInputStream stream = new IgnoreCloseInputStream(underlyingStream);

        assertEquals('A', stream.read());

        // Create a temporary file with test data
        File tempFile = File.createTempFile("test-", ".tmp");
        try (FileOutputStream fos = new FileOutputStream(tempFile)) {
            fos.write("ABCDEFGH".getBytes());
        }

        try (TemporaryFileInputStream stream = new TemporaryFileInputStream(tempFile)) {
            // FileInputStream does not support mark/reset
            assertFalse(stream.markSupported());

    //     the smaller of these blocks with the far end of the other one. That leaves us with a
    //     smaller version of the same problem.
    //     Say we are rotating abcdefgh by 5. We start with abcde|fgh. The smaller block is [fgh]:
    //     [abc]de|[fgh] -> [fgh]de|[abc]. Now [fgh] is in the right place, but we need to swap [de]

        }
      },
    )
  }

  @Test fun goAwayWithDebugDataRoundTrip() {
    val expectedError = ErrorCode.PROTOCOL_ERROR
    val expectedData: ByteString = "abcdefgh".encodeUtf8()

    // Compose the expected GOAWAY frame without debug data.
    writeMedium(frame, 8 + expectedData.size)
    frame.writeByte(TYPE_GOAWAY)
    frame.writeByte(FLAG_NONE)

  }

  private fun testEarlyDisconnectDoesntHarmPooling(transferKind: TransferKind) {
    val mockResponse1 = MockResponse.Builder()
    transferKind.setBody(mockResponse1, "ABCDEFGHIJK", 1024)
    server.enqueue(mockResponse1.build())
    val mockResponse2 = MockResponse.Builder()
    transferKind.setBody(mockResponse2, "LMNOPQRSTUV", 1024)
    server.enqueue(mockResponse2.build())