return n - remain, b.readErr()
		}
	}
}

// Read reads data into p.
// It returns the number of bytes read into p.
// The bytes are taken from at most one Read on the underlying [Reader],
// hence n may be less than len(p).
// To read exactly len(p) bytes, use io.ReadFull(b, p).
// If the underlying [Reader] can return a non-zero count with io.EOF,
// then this Read method can do so as well; see the [io.Reader] docs.

    val body = body("")
    val bytes = body.byteStream()
    assertThat(bytes.read()).isEqualTo(-1)
  }

  @Test
  fun byteStreamSeesBom() {
    val body = body("efbbbf68656c6c6f")
    val bytes = body.byteStream()
    assertThat(bytes.read()).isEqualTo(0xef)
    assertThat(bytes.read()).isEqualTo(0xbb)
    assertThat(bytes.read()).isEqualTo(0xbf)

    }

    private static final Logger logger = Logger.getLogger(JarFileUtil.class);

    /**
     * Creates and returns a <code>JarFile</code> to read the specified JAR file.
     *
     * @param file the file path (must not be {@literal null})
     * @return a <code>JarFile</code> to read the specified JAR file
     */
    public static JarFile create(final String file) {
        assertArgumentNotNull("file", file);

        try {

        // When
        int bytesWritten = response.writeBytesWireFormat(buffer, offset);

        // Then
        assertEquals(0, bytesWritten);
    }

    @Test
    @DisplayName("Should read valid structure from wire format")
    void testReadBytesWireFormatValidStructure() throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[256];
        int offset = 10;

    assertTrue(source.wasStreamOpened());
    assertFalse(source.wasStreamClosed());

    StringWriter writer = new StringWriter();
    char[] buf = new char[64];
    int read;
    while ((read = reader.read(buf)) != -1) {
      writer.write(buf, 0, read);
    }
    reader.close();
    writer.close();

    assertTrue(source.wasStreamClosed());
    assertEquals(STRING, writer.toString());
  }

 *       block indefinitely or fail if the source creates an infinite stream.
 *   <li><b>Non-destructive:</b> A <i>destructive</i> stream will consume or otherwise alter the
 *       bytes of the source as they are read from it. A source that provides such streams will not
 *       be reusable, and operations that read from the stream (including {@link #size()}, in some

     *            The byte buffer. Must not be {@literal null}.
     * @return The number of bytes read.
     */
    public static int read(final FileChannel channel, final ByteBuffer buffer) {
        assertArgumentNotNull("channel", channel);
        assertArgumentNotNull("buffer", buffer);

        try {
            return channel.read(buffer);
        } catch (final IOException e) {
            throw new IORuntimeException(e);

            // Simulate RDMA read operation
            log.debug("DiSNI RDMA read request: {} bytes from remote address 0x{}", bytesToRead, Long.toHexString(remoteAddress));

            return bytesToRead;

        } catch (Exception e) {
            state = RdmaConnectionState.ERROR;
            throw new IOException("DiSNI RDMA read failed", e);
        }
    }

    @Override

    }

    /**
     * Get maximum read/write size
     *
     * @return maximum read/write size in bytes
     */
    public int getMaxReadWriteSize() {
        return maxReadWriteSize;
    }

    /**
     * Set maximum read/write size
     *
     * @param maxReadWriteSize maximum read/write size in bytes
     */

  }

  @Override
  public int read() throws IOException {
    while (in != null) {
      int result = in.read();
      if (result != -1) {
        return result;
      }
      advance();
    }
    return -1;
  }

  @Override
  public int read(byte[] b, int off, int len) throws IOException {
    checkNotNull(b);
    while (in != null) {
      int result = in.read(b, off, len);
      if (result != -1) {