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>

    assertThat(inputStream!!.read()).isEqualTo('A'.code)
    assertThat(inputStream.read()).isEqualTo('B'.code)
    assertThat(inputStream.read()).isEqualTo('C'.code)
    assertThat(inputStream.read()).isEqualTo('D'.code)
    assertThat(inputStream.read()).isEqualTo('E'.code)
    assertThat(inputStream.read()).isEqualTo('F'.code)
    assertThat(inputStream.read()).isEqualTo(-1)

    /** {@link BufferedReader} */
    protected final BufferedReader reader;

    /** The line that has been read */
    protected String line = EMPTY;

    /**
     * Returns an {@link Iterable} that wraps a {@link LineIterator} for use in enhanced for-loops.
     *
     * @param reader
     *            The {@link Reader} to read strings from. Must not be {@literal null}.
     * @return An {@link Iterable} that wraps a {@link LineIterator}.

            else -> source.read(sink, limit)
          }
        }
      }

      override fun timeout(): Timeout = timeout
    }

    /**
     * Returns a value in [0..maxByteCount] with the number of bytes that can be read from [source]
     * in the current part. If this returns 0 the current part is exhausted; otherwise it has at
     * least one byte left to read.
     */

// reads in Scanner.Scan.
type slowReader struct {
	max int
	buf io.Reader
}

func (sr *slowReader) Read(p []byte) (n int, err error) {
	if len(p) > sr.max {
		p = p[0:sr.max]
	}
	return sr.buf.Read(p)
}

// genLine writes to buf a predictable but non-trivial line of text of length
// n, including the terminal newline and an occasional carriage return.

    }

    @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")

        response = new Trans2QueryFSInformationResponse(config, FileSystemInformation.SMB_INFO_ALLOCATION);

        byte[] buffer = new byte[10];
        int read = response.readSetupWireFormat(buffer, 0, 10);

        assertEquals(0, read);
    }

    @Test
    void testReadParametersWireFormat() {
        // Test readParametersWireFormat returns 0

        // The content of these bytes is not critical for this test, only that 6 bytes are read.
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06 }; // Sample 6 bytes
        ByteArrayInputStream bais = new ByteArrayInputStream(data);
        SessionRetargetResponsePacket packet = new SessionRetargetResponsePacket();

        // Create a buffer large enough to hold the read bytes
        byte[] buffer = new byte[6];

//   - Exactly 0 bytes are read and EOF is hit.
//   - Exactly 1 block of zeros is read and EOF is hit.
//   - At least 2 blocks of zeros are read.
func (tr *Reader) readHeader() (*Header, *block, error) {
	// Two blocks of zero bytes marks the end of the archive.
	if _, err := io.ReadFull(tr.r, tr.blk[:]); err != nil {
		return nil, nil, err // EOF is okay here; exactly 0 bytes read
	}

    /**
     * Record start of a read request
     *
     * @param bytes number of bytes being requested
     */
    public void recordReadRequest(int bytes) {
        // Track that a read was requested
        rdmaReads.incrementAndGet();
    }

    /**
     * Record successful completion of a read request
     *
     * @param bytes number of bytes successfully read