// as an error to be reported.
func ReadFileWithFileInfo(name string) ([]byte, fs.FileInfo, error) {
	f, err := OsOpenFile(name, readMode, 0o666)
	if err != nil {
		return nil, nil, err
	}
	defer f.Close()

	st, err := f.Stat()
	if err != nil {
		return nil, nil, err
	}

	dst := make([]byte, st.Size())
	_, err = io.ReadFull(f, dst)
	return dst, st, err
}

        this.server = server;
    }

    @Override
    int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        // Manually set parameters that would be read by readParametersWireFormat
        response.numEntries = 2;
        byte[] params = { 0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x02, 0x00 };
        response.readParametersWireFormat(params, 0, params.length);

        // Data block: 2 entries
        byte[] data = new byte[100];
        // Entry 1: SHARE1, type 0 (Disk), remark "Remark 1"

	h := [3]uintptr{x[0], x[1], x[1]}
	buf := *(*[]byte)(unsafe.Pointer(&h))
	return r.Write(buf)
}

// Bytes returns all available read bytes.
// It does not move the read pointer and only copy the available data.
// If the dst is big enough it will be used as destination,
// otherwise a new buffer will be allocated.
func (r *RingBuffer) Bytes(dst []byte) []byte {
	r.mu.Lock()
	defer r.mu.Unlock()

}

// MarshalMsg implements msgp.Marshaler
func (z BatchKeyRotationType) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendString(o, string(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *BatchKeyRotationType) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 string
		zb0001, bts, err = msgp.ReadStringBytes(bts)

        void readDirectZeroLen() throws Exception {
            SmbFileInputStream in = newStream();
            byte[] buf = new byte[4];
            assertEquals(0, in.readDirect(buf, 0, 0));
            assertEquals(0, in.read(new byte[0]));
        }

        @Test
        @DisplayName("read after close throws 'Bad file descriptor'")
        void readAfterCloseThrows() throws Exception {

func (c *ciphertext) UnmarshalJSON(text []byte) error {
	const (
		IVSize    = 16
		NonceSize = 12

		AES256GCM        = "AES-256-GCM-HMAC-SHA-256"
		CHACHA20POLY1305 = "ChaCha20Poly1305"
	)

	type JSON struct {
		Algorithm string `json:"aead"`
		ID        string `json:"id"`
		IV        []byte `json:"iv"`
		Nonce     []byte `json:"nonce"`
		Bytes     []byte `json:"bytes"`
	}
	var value JSON

        this.filename = lastName;
        flags2 = 0;
    }

    @Override
    int writeSetupWireFormat(final byte[] dst, int dstIndex) {
        dst[dstIndex] = subCommand;
        dstIndex++;
        dst[dstIndex++] = (byte) 0x00;
        return 2;
    }

    @Override
    int writeParametersWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;

        writeInt2(sid, dst, dstIndex);

import org.junit.jupiter.api.Test;

class AvPairTest {

    @Test
    void testConstructorAndGetters() {
        // Test with a valid type and raw data
        int type = AvPair.MsvAvTimestamp;
        byte[] raw = new byte[] { 0x01, 0x02, 0x03, 0x04 };
        AvPair avPair = new AvPair(type, raw);

        assertEquals(type, avPair.getType(), "Type should match the constructor argument.");

		if err != nil {
			err = msgp.WrapError(err, "Cache")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *nsScannerOptions) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--