case SMB_QUERY_FS_SIZE_INFO -> readSmbQueryFSSizeInfoWireFormat(buffer, bufferIndex);
        case SMB_FS_FULL_SIZE_INFORMATION -> readFsFullSizeInformationWireFormat(buffer, bufferIndex);
        default -> 0;
        };
    }

    int readSmbInfoAllocationWireFormat(final byte[] buffer, int bufferIndex) {
        final int start = bufferIndex;

        setFieldValue(response, "wordCount", 10);

        byte[] buffer = new byte[256];
        SMBUtil.writeInt2(fileAttribute, buffer, 0);
        SMBUtil.writeUTime(0, buffer, 2);
        SMBUtil.writeInt4(0, buffer, 6);

        response.readParameterWordsWireFormat(buffer, 0);

        assertEquals(fileAttribute, response.getAttributes());
    }

    @ParameterizedTest

        // Encode to buffer
        byte[] buffer = new byte[50];
        int encodedBytes = original.encode(buffer, 0);

        // Decode to new instance (decode reads 36 bytes, encode writes 40)
        FileBasicInfo decoded = new FileBasicInfo();
        int decodedBytes = decoded.decode(buffer, 0, 36);

        // Verify encoding/decoding

    }

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

        // Validate minimum buffer size for SMB2 negotiate response
        if (buffer == null || buffer.length < bufferIndex + 65) {
            throw new SMBProtocolDecodingException("Buffer too small for SMB2 negotiate response (minimum 65 bytes required)");
        }

    assertOnFileDescriptor(content = "Hello") { fd ->
      val requestBody = fd.toRequestBody()

      val buffer = Buffer()
      requestBody.writeTo(buffer)
      assertThat(buffer.readUtf8()).isEqualTo("Hello")

      assertThrows(IOException::class.java) {
        requestBody.writeTo(Buffer())
      }
    }
  }

  @Test
  fun testFileDescriptorAfterClose() {

            buffer.append(ALPHABET.charAt(block >>> 6 & 0x3f));
            buffer.append(ALPHABET.charAt(block & 0x3f));
        }
        if (remainder == 0) {
            return buffer.toString();
        }
        if (remainder == 1) {
            block = (bytes[i] & 0xff) << 4;
            buffer.append(ALPHABET.charAt(block >>> 6));
            buffer.append(ALPHABET.charAt(block & 0x3f));
            buffer.append("==");

     */
    @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;

    public void testBufferCreation() throws UnsupportedEncodingException {
        byte[] dataBytes = { 1, 2, 3, 4 };
        String params = "test";
        byte[] buffer = createBuffer(10, dataBytes, params);

        // Verify buffer structure
        assertTrue(buffer.length >= 14, "Buffer should contain header, params and data");
    }

    @Test
    public void testByteOperations() {

        byte[] buffer = new byte[20];
        // Mock data for SmbInfoAllocation
        // idFileSystem (4 bytes, skipped)
        writeInt4(100, buffer, 4); // sectPerAlloc
        writeInt4(1000, buffer, 8); // alloc
        writeInt4(500, buffer, 12); // free
        writeInt2(512, buffer, 16); // bytesPerSect

        int bytesRead = response.readDataWireFormat(buffer, 0, buffer.length);

    @Test
    void testNegativeValueHandling() {
        byte[] buffer = new byte[8];

        // Test negative values in writeInt4
        SMBUtil.writeInt4(-1L, buffer, 0);
        assertEquals(-1, SMBUtil.readInt4(buffer, 0));

        // Test negative values in writeInt8
        SMBUtil.writeInt8(-1L, buffer, 0);
        assertEquals(-1L, SMBUtil.readInt8(buffer, 0));
    }