decodedName.decode(decodeBuffer);

        // Verify the decoded data matches
        assertEquals(translatedName.sid_type, decodedName.sid_type);
        // The decode process doesn't preserve the original length, it reads from the buffer
        assertNotNull(decodedName.name);
        assertNotNull(decodedName.name.buffer);
        // Buffer length is based on maximum_length/2 from the encoded data

        assertEquals(TransPeekNamedPipeResponse.STATUS_LISTENING, response.getStatus());
        // Middle bytes were read but not used
    }

    @Test
    @DisplayName("Test consecutive reads update state correctly")
    void testConsecutiveReads() {
        // First read
        byte[] buffer1 = new byte[10];
        SMBUtil.writeInt2(100, buffer1, 0);
        SMBUtil.writeInt2(0, buffer1, 2);

	}
}

// slowReader is a reader that returns only a few bytes at a time, to test the incremental
// 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

        return Smb2Constants.SMB2_HEADER_LENGTH;
    }

    /**
     * Reads the SMB2 header from the wire format.
     *
     * @param buffer the buffer to read from
     * @param bufferIndex the starting position in the buffer
     * @return number of bytes read
     */
    protected int readHeaderWireFormat(final byte[] buffer, int bufferIndex) {

	// iostat related
	driveReadsPerSecMD = NewGaugeMD(driveReadsPerSec,
		"Reads per second on a drive",
		allDriveLabels...)
	driveReadsKBPerSecMD = NewGaugeMD(driveReadsKBPerSec,
		"Kilobytes read per second on a drive",
		allDriveLabels...)
	driveReadsAwaitMD = NewGaugeMD(driveReadsAwait,
		"Average time for read requests served on a drive",
		allDriveLabels...)
	driveWritesPerSecMD = NewGaugeMD(driveWritesPerSec,

		return errFileNotFound
	}
	if isSysErrIO(err) {
		return errFaultyDisk
	}
	if isSysErrInvalidArg(err) {
		storageLogIf(context.Background(), err)
		// For some odd calls with O_DIRECT reads
		// filesystems can return EINVAL, handle
		// these as FileNotFound instead.
		return errFileNotFound
	}
	if isSysErrNoSpace(err) {
		return errDiskFull
	}
	return err

private fun BufferedSource.skipRestOfLine() {
  when (val newline = indexOf('\n'.code.toByte())) {
    -1L -> skip(buffer.size) // Exhaust this source.
    else -> skip(newline + 1)
  }
}

/**
 * Reads lines from `IdnaMappingTable.txt`.
 *
 * Comment lines are either blank or start with a `#` character. Lines may also end with a comment.
 * All comments are ignored.
 *

import java.util.Map;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * Test cases for a {@link Table} implementation supporting reads and writes.
 *
 * @author Jared Levy
 * @author Louis Wasserman
 */
@GwtCompatible
@NullMarked
public abstract class AbstractTableTest<C extends @Nullable Character>
    extends AbstractTableReadTest<C> {

        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

        update(sequence, 0, sequence.length);
        index += 8;
        if (msg.getCommand() == ServerMessageBlock.SMB_COM_READ_ANDX) {
            /*
             * SmbComReadAndXResponse reads directly from the stream into separate byte[] b.
             */
            final SmbComReadAndXResponse raxr = (SmbComReadAndXResponse) msg;
            final int length = msg.getLength() - raxr.getDataLength();