}

    /**
     * Append content to the message buffer.
     *
     * @param value the content to append
     * @return the current builder
     */
    @Nonnull
    default MessageBuilder a(char[] value) {
        return append(String.valueOf(value));
    }

    /**
     * Append content to the message buffer.
     *
     * @param value the content to append

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

        this.leaseFlags = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

        // LeaseDuration (8 bytes) - reserved, skip
        bufferIndex += 8;

        byte[] parentKeyBytes = new byte[16];
        System.arraycopy(buffer, bufferIndex, parentKeyBytes, 0, 16);

    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.allocationSize = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        this.endOfFile = SMBUtil.readInt8(buffer, bufferIndex);
        bufferIndex += 8;
        this.numberOfLinks = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;

    protected int readBytesWireFormat(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = bufferIndex;

        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 9) {
            throw new SMBProtocolDecodingException("Expected structureSize = 9");
        }

        final int bufferOffset = SMBUtil.readInt2(buffer, bufferIndex + 2) + getHeaderStart();

        // Given
        byte[] buffer = new byte[256];
        int offset = 10;
        int size = 100;
        when(response.verifySignature(buffer, offset, size)).thenReturn(true);

        // When
        boolean verified = response.verifySignature(buffer, offset, size);

        // Then
        assertTrue(verified);
        verify(response).verifySignature(buffer, offset, size);
    }

    @Test

  @J2ktIncompatible
  @GwtIncompatible // BlockingQueue
  public static <E> int drain(
      BlockingQueue<E> q, Collection<? super E> buffer, int numElements, Duration timeout)
      throws InterruptedException {
    // TODO(b/126049426): Consider using saturateToNanos(timeout) instead.
    return drain(q, buffer, numElements, timeout.toNanos(), NANOSECONDS);
  }

  /**

	v := BatchJobPrefix{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodeBatchJobPrefix(b *testing.B) {
	v := BatchJobPrefix{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))

	v := localLockMap{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))
	en := msgp.NewWriter(msgp.Nowhere)
	b.ReportAllocs()
	b.ResetTimer()
	for i := 0; i < b.N; i++ {
		v.EncodeMsg(en)
	}
	en.Flush()
}

func BenchmarkDecodelocalLockMap(b *testing.B) {
	v := localLockMap{}
	var buf bytes.Buffer
	msgp.Encode(&buf, &v)
	b.SetBytes(int64(buf.Len()))

        byte[] buffer = new byte[10];
        int result = smbCom.readParameterWordsWireFormat(buffer, 0);
        assertEquals(0, result);
    }

    @Test
    void testReadBytesWireFormat() {
        // This method is empty, so it should return 0
        SmbComCreateDirectory smbCom = new SmbComCreateDirectory(mockConfig, "testDir");
        byte[] buffer = new byte[10];

        server.maxMpxCount = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        server.maxNumberVcs = readInt2(buffer, bufferIndex);
        bufferIndex += 2;
        server.maxBufferSize = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        server.maxRawSize = readInt4(buffer, bufferIndex);
        bufferIndex += 4;
        server.sessionKey = readInt4(buffer, bufferIndex);
        bufferIndex += 4;