}
    }
  }

  abstract val path: Any

  /**
   * Reads the public suffix list treating the operation as uninterruptible. We always want to read
   * the list otherwise we'll be left in a bad state. If the thread was interrupted prior to this
   * operation, it will be re-interrupted after the list is read.
   */
  private fun readTheListUninterruptibly() {
    var interrupted = false
    try {

    or a <i>synchronizing operation</i> such as an atomic data access,
	a mutex operation, or a channel operation,</li>
	<li>its location in the program,</li>
	<li>the memory location or variable being accessed, and</li>
	<li>the values read or written by the operation.</li>
</ul>
<p>

    /**
     * Reads setup data from wire format
     * @param buffer source buffer
     * @param bufferIndex starting index in source buffer
     * @param len length of data to read
     * @return number of bytes read
     */
    protected abstract int readSetupWireFormat(byte[] buffer, int bufferIndex, int len);

    /**
     * Reads parameters from wire format

      }
    }

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

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

    @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());

 */
public interface DocumentReader extends Closeable {
    /**
     * Reads a document and returns its contents as a map.
     *
     * @return a map containing the document's data, or null if there are no more documents to read.
     */
    Map<String, Object> read();

    @Override
    void close();

        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

   * [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.
   *

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