return this.pid;
    }

    /**
     * Returns the starting byte offset of the lock range.
     *
     * @return the starting byte offset
     */
    public long getByteOffset() {
        return this.byteOffset;
    }

    /**
     * Returns the byte length of the lock range.
     *
     * @return the byte length of the range
     */
    public long getLengthInBytes() {

     */
    public WitnessHeartbeatMessage(byte[] contextHandle, long sequenceNumber) {
        super(WITNESS_HEARTBEAT);
        this.contextHandle = contextHandle != null ? contextHandle.clone() : new byte[20];
        this.sequenceNumber = sequenceNumber;
        this.responseSequenceNumber = 0;
        this.heartbeatInterval = 0;
    }

    /**
     * Sets the context handle for the heartbeat.

    }

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

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

        dst[dstIndex] = (byte) 0x04;
        dstIndex++;
        dstIndex += writeString(path, dst, dstIndex);

	stringToSign += scope + "\n"
	canonicalRequestBytes := sha256.Sum256([]byte(canonicalRequest))
	stringToSign += hex.EncodeToString(canonicalRequestBytes[:])
	return stringToSign
}

// getSigningKey hmac seed to calculate final signature.
func getSigningKey(secretKey string, t time.Time, region string, stype serviceType) []byte {
	date := sumHMAC([]byte("AWS4"+secretKey), []byte(t.Format(yyyymmdd)))
	regionBytes := sumHMAC(date, []byte(region))

     */
    int read(byte[] b) throws SmbException;

    /**
     * Read into buffer from current position
     *
     * @param b
     *            buffer
     * @param off
     *            offset into buffer
     * @param len
     *            read up to <code>len</code> bytes
     * @return number of bytes read
     * @throws SmbException if an I/O error occurs during read
     */

    int writeSetupWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

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

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

    @Override

    }

    /**
     * Test of readParameterWordsWireFormat method
     */
    @Test
    public void testReadParameterWordsWireFormat() {
        // Given
        byte[] buffer = new byte[] { (byte) 0xff, (byte) 0xff, 0, 0, 0, 0, 0, 0 };
        SmbComWriteAndXResponse instance = new SmbComWriteAndXResponse(config);

        // When
        int result = instance.readParameterWordsWireFormat(buffer, 0);

        v.add(new DERTaggedObject(true, 2, new DERBitString(new byte[] { apOptions }))); // first byte read by impl
        return new DERSequence(v);
    }

    @Test
    @DisplayName("byte[] ctor: empty token throws PACDecodingException with clear message")
    void byteArrayConstructor_emptyToken_throws() {
        // Arrange
        byte[] empty = new byte[0];

        // Act + Assert

		return
	}
	return
}

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

// UnmarshalMsg implements msgp.Unmarshaler
func (z *BitrotAlgorithm) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 uint
		zb0001, bts, err = msgp.ReadUintBytes(bts)
		if err != nil {

        maxSetupCount = (byte) 0x00;
        setupCount = 0;
        timeout = 5000;
    }

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

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

        try {