}

    /**
     * Get preferred send size
     *
     * @return preferred send size in bytes
     */
    public int getPreferredSendSize() {
        return preferredSendSize;
    }

    /**
     * Set preferred send size
     *
     * @param preferredSendSize preferred send size in bytes
     */
    public void setPreferredSendSize(int preferredSendSize) {

import (
	"bytes"
	"testing"

	"github.com/tinylib/msgp/msgp"
)

func TestMarshalUnmarshalBucketReplicationStat(t *testing.T) {
	v := BucketReplicationStat{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)

import (
	"bytes"
	"testing"

	"github.com/tinylib/msgp/msgp"
)

func TestMarshalUnmarshalChecksumInfo(t *testing.T) {
	v := ChecksumInfo{}
	bts, err := v.MarshalMsg(nil)
	if err != nil {
		t.Fatal(err)
	}
	left, err := v.UnmarshalMsg(bts)
	if err != nil {
		t.Fatal(err)
	}
	if len(left) > 0 {
		t.Errorf("%d bytes left over after UnmarshalMsg(): %q", len(left), left)
	}

        // LeaseKey (16 bytes)
        byte[] keyBytes = new byte[16];
        System.arraycopy(buffer, bufferIndex, keyBytes, 0, 16);
        this.leaseKey = new Smb2LeaseKey(keyBytes);
        bufferIndex += 16;

        // LeaseState (4 bytes)
        this.leaseState = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // LeaseDuration (8 bytes)

    }

    /**
     * Get maximum receive size
     *
     * @return maximum receive size in bytes
     */
    public int getMaxReceiveSize() {
        return maxReceiveSize;
    }

    /**
     * Set maximum receive size
     *
     * @param maxReceiveSize maximum receive size in bytes
     */
    public void setMaxReceiveSize(int maxReceiveSize) {
        this.maxReceiveSize = maxReceiveSize;

	if err != nil {
		t.Fatalf("%s: <ERROR> %s", instanceType, err)
	}
	if len(bytesBuffer1.Bytes()) != len(content) {
		t.Errorf("%s: Expected content length to be `%d`, but instead found `%d`", instanceType, len(content), len(bytesBuffer1.Bytes()))
	}

	var bytesBuffer2 bytes.Buffer
	_, err = obj.PutObject(context.Background(), "bucket", "object", mustGetPutObjReader(t, readerNoEOF, length, "", ""), opts)

    }
  }

  override fun onMessage(
    webSocket: WebSocket,
    bytes: ByteString,
  ) {
    Platform.get().log("[WS $name] onMessage", Platform.INFO, null)
    val delegate = delegate
    if (delegate != null) {
      this.delegate = null
      delegate.onMessage(webSocket, bytes)
    } else {
      events.add(Message(bytes = bytes))
    }
  }

  override fun onMessage(
    webSocket: WebSocket,

        // Verify bytes written
        assertEquals(8, bytesWritten);

        // Verify FID (2 bytes)
        assertEquals(fid, SMBUtil.readInt2(dst, dstIndex));

        // Verify reserved bytes (2 bytes at positions 2-3)
        assertEquals(0x00, dst[dstIndex + 2]);
        assertEquals(0x00, dst[dstIndex + 3]);

        // Verify security information (4 bytes)

  /**
   * Load 8 bytes into long in a little endian manner, from the substring between position and
   * position + 8. The array must have at least 8 bytes from offset (inclusive).
   *
   * @param input the input bytes
   * @param offset the offset into the array at which to start
   * @return a long of a concatenated 8 bytes
   */
  static long load64(byte[] input, int offset) {

        }

        @Override
        int writeParameterWordsWireFormat(byte[] dst, int dstIndex) {
            System.arraycopy(paramWords, 0, dst, dstIndex, paramWords.length);
            return paramWords.length;
        }

        @Override
        int writeBytesWireFormat(byte[] dst, int dstIndex) {
            System.arraycopy(bytes, 0, dst, dstIndex, bytes.length);
            return bytes.length;