int readHeaderWireFormat(final byte[] buffer, final int bufferIndex) {
        command = buffer[bufferIndex + CMD_OFFSET];
        errorCode = readInt4(buffer, bufferIndex + ERROR_CODE_OFFSET);
        flags = buffer[bufferIndex + FLAGS_OFFSET];
        flags2 = readInt2(buffer, bufferIndex + FLAGS_OFFSET + 1);
        tid = readInt2(buffer, bufferIndex + TID_OFFSET);
        pid = readInt2(buffer, bufferIndex + TID_OFFSET + 2);

   * most [BufferedSource] instances, but not of [Buffer].
   */
  private fun responseBody(content: String): ResponseBody {
    val data = Buffer().writeUtf8(content)
    val source: Source =
      object : Source {
        var closed = false

        override fun close() {
          closed = true
        }

        override fun read(
          sink: Buffer,
          byteCount: Long,
        ): Long {

        } else {
          var buffer = Buffer()
          requestBody.writeTo(buffer)

          var gzippedLength: Long? = null
          if ("gzip".equals(headers["Content-Encoding"], ignoreCase = true)) {
            gzippedLength = buffer.size
            GzipSource(buffer).use { gzippedResponseBody ->
              buffer = Buffer()
              buffer.writeAll(gzippedResponseBody)
            }

        byte[] buffer = new byte[10];

        // Act
        int bytesWritten = transPeekNamedPipe.writeSetupWireFormat(buffer, 0);

        // Assert
        assertEquals(4, bytesWritten);
        assertEquals(SmbComTransaction.TRANS_PEEK_NAMED_PIPE, buffer[0]);
        assertEquals((byte) 0x00, buffer[1]);
        assertEquals((byte) 0x00, buffer[2]);
        assertEquals((byte) 0x00, buffer[3]);

            // Verify output buffer length
            assertEquals(0x8000, SMBUtil.readInt4(buffer, 68));

            // Verify input buffer offset (should be 0 when no input buffer)
            assertEquals(0, SMBUtil.readInt2(buffer, 72));

            // Verify input buffer length (should be 0 when no input buffer)
            assertEquals(0, SMBUtil.readInt4(buffer, 76));

            // Verify additional information

        byte[] buffer = new byte[512];
        // Fill buffer with non-zero values to ensure padding writes zeros
        for (int i = 0; i < buffer.length; i++) {
            buffer[i] = (byte) 0xFF;
        }

        int written = trans2SetFileInfo.writeDataWireFormat(buffer, 0);

        // Should report 26 bytes written (20 from encode + 6 increment)

    protected int readBytesWireFormat(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 16) {
            throw new SMBProtocolDecodingException("Structure size is not 16");
        }

        this.shareType = buffer[bufferIndex + 2];
        bufferIndex += 4;

    void testWireFormatStructure() {
        byte[] buffer = new byte[256];
        Arrays.fill(buffer, (byte) 0xCC); // Fill with pattern to detect unwritten areas

        int written = request.writeBytesWireFormat(buffer, 0);

        // Verify structure according to SMB2 FLUSH specification
        // Structure Size (2 bytes) - should be 24
        assertEquals(24, SMBUtil.readInt2(buffer, 0));

                if (!currentArg.isEmpty()) {
                    currentArg.setLength(currentArg.length() - 1);
                }

                cleaned.add(currentArg.toString());

                currentArg = null;
                continue;
            }

            // if we haven't added this arg to the buffer, and we ARE building an argument

     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        this.replaceIfExists = buffer[bufferIndex] != 0;
        bufferIndex += 8;
        bufferIndex += 8;

        final int nameLen = SMBUtil.readInt4(buffer, bufferIndex);
        bufferIndex += 4;