}

    /**
     * Reads bytes from the file into the specified byte array.
     *
     * @param b the byte array to read data into
     * @return the number of bytes read, or -1 if end of file is reached
     * @throws SmbException if an I/O error occurs
     */
    public int read(final byte b[]) throws SmbException {
        return read(b, 0, b.length);
    }

    /**

      }
    }

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

        // Read first message
        assertEquals(1, sis.read());
        assertEquals(2, sis.read());

        // Read second message
        assertEquals(3, sis.read());
        assertEquals(4, sis.read());
        assertEquals(5, sis.read());

        // After all data is consumed, next read throws IOException
        assertThrows(IOException.class, () -> sis.read());
    }

    @Test

    byte[] buf = createBuffer();
    int read;
    do {
      read = input.read(buf);
    } while (read != -1 && processor.processBytes(buf, 0, read));
    return processor.getResult();
  }

  /**
   * Reads some bytes from an input stream and stores them into the buffer array {@code b}. This
   * method blocks until {@code len} bytes of input data have been read into the array, or end of

    // The stream reports no bytes... importantly, it doesn't read the byte at index 5 when it
    // should be reading the byte at index 10.
    // We could use a custom InputStream instead to make the read start at index 10, but since this
    // is a racy situation anyway, this behavior seems reasonable.
    assertEquals(-1, in.read());
  }

  private static class AppendableByteSource extends ByteSource {

            // Simple mock implementation
            byte[] temp = new byte[length];
            int read = in.read(temp, 0, length);
            if (read < length) {
                throw new IOException("Incomplete trailer data");
            }
            trailerBytesRead = read;
            return read;
        }
    }

    assertEquals(2, lin.available());
    int read = lin.read();
    assertEquals(big[0], read);
    assertEquals(1, lin.available());
    read = lin.read();
    assertEquals(big[1], read);
    assertEquals(0, lin.available());
    read = lin.read();
    assertEquals(-1, read);

    lin.reset();
    byte[] small = new byte[5];
    read = lin.read(small);
    assertEquals(2, read);
    assertEquals(big[0], small[0]);

    collected using form data (instead of JSON) and that it should have the specific
    fields `username` and `password`.

    All the initialization parameters are extracted from the request.

    Read more about it in the
    [FastAPI docs for Simple OAuth2 with Password and Bearer](https://fastapi.tiangolo.com/tutorial/security/simple-oauth2/).

    ## Example

    ```python
    from typing import Annotated

        }
    }

    @Override
    public int read() throws SmbException {
        if (read(this.tmp, 0, 1) == -1) {
            return -1;
        }
        return this.tmp[0] & 0xFF;
    }

    @Override
    public int read(final byte b[]) throws SmbException {
        return read(b, 0, b.length);
    }

    @Override
    public int read(final byte b[], int off, int len) throws SmbException {

		return r.err
	}
	return nil
}

// Read reads up to len(p) bytes into p. It returns the number of bytes read (0 <= n <= len(p)) and any error encountered.
// Even if Read returns n < len(p), it may use all of p as scratch space during the call.
// If some data is available but not len(p) bytes, Read conventionally returns what is available instead of waiting for more.