// StructureSize (2 bytes) - must be 44
        writeInt2(dst, dstIndex, 44);
        dstIndex += 2;
        
        // Reserved (2 bytes)
        writeInt2(dst, dstIndex, 0);
        dstIndex += 2;
        
        // Flags (4 bytes)
        writeInt4(dst, dstIndex, flags);
        dstIndex += 4;
        
        // LeaseKey (16 bytes)

  public void testMumurHash64() {
    byte[] bytes = "test".getBytes(UTF_8);
    assertEquals(
        1618900948208871284L, Fingerprint2011.murmurHash64WithSeed(bytes, 0, bytes.length, 1));

    bytes = "test test test".getBytes(UTF_8);
    assertEquals(
        UnsignedLong.valueOf("12313169684067793560").longValue(),
        Fingerprint2011.murmurHash64WithSeed(bytes, 0, bytes.length, 1));
  }

		genLine(tmp, lineNum, j, false)
		if j < smallMaxTokenSize {
			j++
		} else {
			j--
		}
		line := tmp.Bytes()
		if !bytes.Equal(s.Bytes(), line) {
			t.Errorf("%d: bad line: %d %d\n%.100q\n%.100q\n", lineNum, len(s.Bytes()), len(line), s.Bytes(), line)
		}
	}
	err := s.Err()
	if err != ErrTooLong {
		t.Fatalf("expected ErrTooLong; got %s", err)
	}
}

        }

        // Setters for test control
        void setSetupBytesWritten(int bytes) {
            this.setupBytesWritten = bytes;
        }

        void setParameterBytesWritten(int bytes) {
            this.parameterBytesWritten = bytes;
        }

        void setDataBytesWritten(int bytes) {
            this.dataBytesWritten = bytes;
        }
    }

    @BeforeEach
    void setUp() {

    }

    /**
     * Add bytes sent
     *
     * @param bytes number of bytes
     */
    public void addBytesSent(long bytes) {
        bytesSent.addAndGet(bytes);
    }

    /**
     * Add bytes received
     *
     * @param bytes number of bytes
     */
    public void addBytesReceived(long bytes) {
        bytesReceived.addAndGet(bytes);
    }

    /**

import (
	"bytes"
	"testing"

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

func TestMarshalUnmarshalnsScannerOptions(t *testing.T) {
	v := nsScannerOptions{}
	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)
	}

        // idFileSystem (4 bytes) - skipped in decode
        SMBUtil.writeInt4(0, buffer, offset);
        offset += 4;

        // sectPerAlloc (4 bytes)
        SMBUtil.writeInt4(8, buffer, offset);
        offset += 4;

        // alloc (4 bytes)
        SMBUtil.writeInt4(1000000, buffer, offset);
        offset += 4;

        // free (4 bytes)
        SMBUtil.writeInt4(500000, buffer, offset);

        // TID (2 bytes)
        buffer[24] = 0x01;
        buffer[25] = 0x00;

        // PID (2 bytes)
        buffer[26] = 0x02;
        buffer[27] = 0x00;

        // UID (2 bytes)
        buffer[28] = 0x03;
        buffer[29] = 0x00;

        // MID (2 bytes)
        buffer[30] = 0x04;
        buffer[31] = 0x00;

        // Word count
        buffer[32] = 10; // 10 words = 20 bytes

   *
   * If this flag is set, the next four
   * bytes represent the mask key. These bytes appear after any additional bytes specified by [B1_MASK_LENGTH].
   */
  internal const val B1_FLAG_MASK = 128

  /**
   * Byte 1 mask for the payload length.
   *
   * If this value is [PAYLOAD_SHORT], the next two
   * bytes represent the length. If this value is [PAYLOAD_LONG], the next eight bytes
   * represent the length.
   */

    }

    val bytes = source().use(consumer)
    val size = sizeMapper(bytes)
    if (contentLength != -1L && contentLength != size.toLong()) {
      throw IOException("Content-Length ($contentLength) and stream length ($size) disagree")
    }
    return bytes
  }

  /**
   * Returns the response as a character stream.
   *