@Throws(IOException::class)
    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      while (left == 0) {
        source.skip(padding.toLong())
        padding = 0
        if (flags and FLAG_END_HEADERS != 0) return -1L
        readContinuationHeader()
        // TODO: test case for empty continuation header?
      }

      val read = source.read(sink, minOf(byteCount, left.toLong()))

    }

    @Test
    @DisplayName("read(byte[],off,0): returns 0 without I/O")
    void read_lenZero_returnsZero() throws Exception {
        SmbRandomAccessFile raf = newInstance("r", false, false, false);
        byte[] buf = new byte[4];
        assertEquals(0, raf.read(buf, 0, 0));
    }

    @Test
    @DisplayName("read(): returns -1 when underlying read reports EOF")

      }
    }

    override fun read(
      sink: Buffer,
      byteCount: Long,
    ): Long {
      require(byteCount >= 0L) { "byteCount < 0: $byteCount" }
      check(!closed) { "closed" }
      if (bytesRemaining == 0L) return -1

      val read = super.read(sink, minOf(bytesRemaining, byteCount))
      if (read == -1L) {

/**
 * This class will allow a Java program to read and write data to Named
 * Pipes and Transact NamedPipes.
 *
 * <p>There are three Win32 function calls provided by the Windows SDK
 * that are important in the context of using jCIFS. They are:
 *
 * <ul>
 * <li> <code>CallNamedPipe</code> A message-type pipe call that opens,
 *      writes to, reads from, and closes the pipe in a single operation.

    @Nested
    @DisplayName("Integration Tests")
    class IntegrationTests {

        @Test
        @DisplayName("Should maintain state after multiple reads")
        void testMultipleReads() throws SMBProtocolDecodingException {
            // First read
            byte[] buffer1 = createValidWriteResponse(1024, 512);
            response.readBytesWireFormat(buffer1, 0);
            assertEquals(1024, response.getCount());

        offset += 2;

        // Decode
        int bytesDecoded = smbInfoAllocation.decode(buffer, 0, buffer.length);

        // Verify - actual implementation reads 20 bytes (4 + 4 + 4 + 4 + 4)
        // bytesPerSect is read as Int2 but advances by 4 bytes (padding)
        assertEquals(20, bytesDecoded);

        // Verify capacity calculation: alloc * sectPerAlloc * bytesPerSect

        }
    });
}
```

### 5.3 Read/Write Operations with Multi-Channel
```java
// In SmbFile.java
public void optimizedLargeRead(byte[] buffer, long offset, int length) throws IOException {
    if (!session.isMultiChannelEnabled() || length < 1048576) {  // 1MB threshold
        // Use single channel for small reads
        normalRead(buffer, offset, length);
        return;
    }
    

   * [Call.request] is a redirect to a different address.
   *
   * Prior to OkHttp 4.3 this was incorrectly invoked when the client was ready to read headers.
   * This was misleading for tracing because it was too early.
   */
  open fun responseHeadersStart(call: Call) {
  }

  /**
   * Invoked immediately after receiving response headers.
   *

        readStory(story00)
        result.add(path.name)
      } catch (ignored: IOException) {
        // Skip this path.
      }
    }
    return result.toTypedArray<String>()
  }

  /**
   * Reads stories named "story_xx.json" from the folder provided.
   */
  fun readStories(testFolderName: String): List<Story> {
    val result = mutableListOf<Story>()
    var i = 0
    while (true) { // break after last test.

   */
  public static byte[] toByteArray(File file) throws IOException {
    return asByteSource(file).read();
  }

  /**
   * Reads all characters from a file into a {@link String}, using the given character set.
   *
   * @param file the file to read from
   * @param charset the charset used to decode the input stream; see {@link StandardCharsets} for
   *     helpful predefined constants