/**
 * Utility class for conversions related to byte arrays.
 *
 * @author higa
 */
public abstract class BinaryConversionUtil {

    /**
     * Do not instantiate.
     */
    protected BinaryConversionUtil() {
    }

    /**
     * Converts to a {@literal byte} array.
     *
     * @param o
     *            The object to convert
     * @return The {@literal byte} array
     */

    void testReadParametersWireFormatIgnoresMiddleBytes() {
        // Arrange
        byte[] buffer = new byte[10];
        SMBUtil.writeInt2(200, buffer, 0);
        // These bytes should be ignored
        buffer[2] = (byte) 0xFF;
        buffer[3] = (byte) 0xFF;
        SMBUtil.writeInt2(TransPeekNamedPipeResponse.STATUS_LISTENING, buffer, 4);

        // Act

    public static final byte TRANS2_SET_FILE_INFORMATION = (byte) 0x08;

    /**
     * Network share enumeration subcommand
     */
    public static final byte NET_SHARE_ENUM = (byte) 0x00;
    /**
     * Network server enumeration subcommand version 2
     */
    public static final byte NET_SERVER_ENUM2 = (byte) 0x68;
    /**
     * Network server enumeration subcommand version 3
     */

	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()

    void testSetFileId() {
        request = new Smb2QueryDirectoryRequest(mockConfig);
        byte[] fileId = new byte[16];
        for (int i = 0; i < 16; i++) {
            fileId[i] = (byte) (i + 1);
        }

        request.setFileId(fileId);

        // Verify by writing to buffer and checking the fileId position
        byte[] buffer = new byte[1024];
        request.writeBytesWireFormat(buffer, Smb2Constants.SMB2_HEADER_LENGTH);

        if (useUnicode) {
            dst[dstIndex++] = (byte) '\0';
        }
        dstIndex += writeString(newFileName, dst, dstIndex);

        return dstIndex - start;
    }

    @Override
    int readParameterWordsWireFormat(final byte[] buffer, final int bufferIndex) {
        return 0;
    }

    @Override
    int readBytesWireFormat(final byte[] buffer, final int bufferIndex) {

     */
    public void setContext(final byte[] context) {
        this.context = context;
    }

    @Override
    public byte[] toByteArray() {
        try {
            final String targetName = getTarget();
            final byte[] challenge = getChallenge();
            byte[] context = getContext();
            final byte[] targetInformation = getTargetInformation();

}

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

}

// MarshalMsg implements msgp.Marshaler
func (z BaseOptions) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 0
	_ = z
	o = append(o, 0x80)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *BaseOptions) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)

        byte[] dst = new byte[10];
        int dstIndex = 0;

        // Act
        int bytesWritten = transWaitNamedPipe.writeSetupWireFormat(dst, dstIndex);

        // Assert
        assertEquals(4, bytesWritten);
        assertEquals(SmbComTransaction.TRANS_WAIT_NAMED_PIPE, dst[0]);
        assertEquals((byte) 0x00, dst[1]);
        assertEquals((byte) 0x00, dst[2]); // no FID