recordDelimiter []byte
	oneByte         []byte
	useOneByte      bool
}

func (rr *recordTransform) Read(p []byte) (n int, err error) {
	if rr.useOneByte {
		p[0] = rr.oneByte[0]
		rr.useOneByte = false
		n, err = rr.reader.Read(p[1:])
		n++
	} else {
		n, err = rr.reader.Read(p)
	}

	if err != nil {
		return n, err
	}

	// Do nothing if record-delimiter is already newline.

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

		panic("Failed to acquire read lock")
	}
	// fmt.Println("1st read lock acquired, waiting...")

	drwm2 := NewDRWMutex(ds, "simplelock")
	ctx2, cancel2 := context.WithCancel(t.Context())
	if !drwm2.GetRLock(ctx2, cancel2, id, source, Options{Timeout: time.Second}) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("2nd read lock acquired, waiting...")

	go func() {

    @Override
    public PersistedToolchains read(File input, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(input, "input cannot be null");

        try (InputStream in = Files.newInputStream(input.toPath())) {
            InputSource source = InputSource.of(input.toString());
            return new PersistedToolchains(new MavenToolchainsStaxReader().read(in, isStrict(options), source));

        }
        bufferIndex += 4;

        // Read signature
        System.arraycopy(buffer, bufferIndex, header.signature, 0, 16);
        bufferIndex += 16;

        // Read nonce
        System.arraycopy(buffer, bufferIndex, header.nonce, 0, 16);
        bufferIndex += 16;

        // Read original message size
        header.originalMessageSize = SMBUtil.readInt4(buffer, bufferIndex);

    }

    /**
     * Returns the contents read from the reader as a string.
     *
     * @param reader
     *            the reader
     * @param initialCapacity
     *            the initial buffer capacity
     * @return the string read from the reader
     */
    protected static String read(final Reader reader, final int initialCapacity) {
        int bufferSize;

@Singleton
public class DefaultMetadataReader implements MetadataReader {

    @Override
    public Metadata read(File input, Map<String, ?> options) throws IOException {
        Objects.requireNonNull(input, "input cannot be null");

        return read(Files.newInputStream(input.toPath()), options);
    }

    @Override
    public Metadata read(Reader input, Map<String, ?> options) throws IOException {

        You normally wouldn't use this from a file you read in a request.

        To be awaitable, compatible with async, this is run in threadpool.
        """
        return await super().write(data)

    async def read(
        self,
        size: Annotated[
            int,
            Doc(
                """
                The number of bytes to read from the file.
                """
            ),

    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)

	buf bytes.Buffer
	// total bytes read including header size
	bytesRead int
}

// Close is a no operation closer
func (r *RequestRecorder) Close() error {
	// no-op
	return nil
}

// Read reads from the internal reader and counts/save the body in the memory
func (r *RequestRecorder) Read(p []byte) (n int, err error) {
	n, err = r.Reader.Read(p)
	r.bytesRead += n

	if r.LogBody {