*/
    public SmbComReadAndXResponse ( Configuration config, byte[] b, int off ) {
        super(config);
        this.data = b;
        this.offset = off;
    }


    void setParam ( byte[] b, int off ) {
        this.data = b;
        this.offset = off;
    }


    /**
     * 
     * @return the read data
     */
    public final byte[] getData () {
        return this.data;
    }


    /**

     */
    boolean verify(byte[] data, int offset, ServerMessageBlock response) {
        update(macSigningKey, 0, macSigningKey.length);
        int index = offset;
        update(data, index, ServerMessageBlock.SIGNATURE_OFFSET); 
        index += ServerMessageBlock.SIGNATURE_OFFSET;
        byte[] sequence = new byte[8]; 
        ServerMessageBlock.writeInt4(response.signSeq, sequence, 0); 

func (z muxConnectError) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "Error"
	o = append(o, 0x81, 0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72)
	o = msgp.AppendString(o, z.Error)
	return
}

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

    public static class uuid_t extends NdrObject {

        public int time_low;
        public short time_mid;
        public short time_hi_and_version;
        public byte clock_seq_hi_and_reserved;
        public byte clock_seq_low;
        public byte[] node;

        public void encode(NdrBuffer _dst) throws NdrException {
            _dst.align(4);
            _dst.enc_ndr_long(time_low);

package jstream

import (
	"bufio"
	"bytes"
	"fmt"
	"io"
	"sync/atomic"
	"testing"
)

var (
	smallInput  = make([]byte, 1024*12)       // 12K
	mediumInput = make([]byte, 1024*1024*12)  // 12MB
	largeInput  = make([]byte, 1024*1024*128) // 128MB
)

func TestScanner(t *testing.T) {
	data := []byte("abcdefghijklmnopqrstuvwxyz0123456789")

	var i int
	r := bytes.NewReader(data)
	scanner := newScanner(r)

            }));
  }

  public void testRead_usingByteProcessor() throws IOException {
    byte[] readBytes =
        source.read(
            new ByteProcessor<byte[]>() {
              final ByteArrayOutputStream out = new ByteArrayOutputStream();

              @Override
              public boolean processBytes(byte[] buf, int off, int len) throws IOException {
                out.write(buf, off, len);

    abstract int writeSetupWireFormat( byte[] dst, int dstIndex );
    abstract int writeParametersWireFormat( byte[] dst, int dstIndex );
    abstract int writeDataWireFormat( byte[] dst, int dstIndex );
    abstract int readSetupWireFormat( byte[] buffer, int bufferIndex, int len );
    abstract int readParametersWireFormat( byte[] buffer, int bufferIndex, int len );
    abstract int readDataWireFormat( byte[] buffer, int bufferIndex, int len );

  public void testBytes() {
    Sink sink = new Sink(4); // byte order insignificant here
    byte[] expected = {1, 2, 3, 4, 5, 6, 7, 8};
    sink.putByte((byte) 1);
    sink.putBytes(new byte[] {2, 3, 4, 5, 6});
    sink.putByte((byte) 7);
    sink.putBytes(new byte[] {});
    sink.putBytes(new byte[] {8});
    HashCode unused = sink.hash();
    sink.assertInvariants(8);
    sink.assertBytes(expected);

    /**
     * 
     */
    public static final byte SMB2_SHARE_TYPE_DISK = 0x1;
    /**
     * 
     */
    public static final byte SMB2_SHARE_TYPE_PIPE = 0x2;
    /**
     * 
     */
    public static final byte SMB2_SHARE_TYPE_PRINT = 0x3;

    /**
     * 
     */
    public static final int SMB2_SHAREFLAG_MANUAL_CACHING = 0x0;

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


    /**
     * {@inheritDoc}
     *
     * @see jcifs.internal.smb1.ServerMessageBlock#writeBytesWireFormat(byte[], int)
     */
    @Override
    protected int writeBytesWireFormat ( byte[] dst, int dstIndex ) {
        return 0;
    }