byte[] buffer = new byte[28];

        // Fill resume key with test pattern
        for (int i = 0; i < 24; i++) {
            buffer[i] = (byte) (i + 1);
        }

        // Add context length (reserved) - 4 bytes
        buffer[24] = 0x00;
        buffer[25] = 0x00;
        buffer[26] = 0x00;
        buffer[27] = 0x00;

        // Decode

            // Given - first decode
            ByteBuffer buffer1 = ByteBuffer.allocate(24);
            buffer1.order(ByteOrder.LITTLE_ENDIAN);
            buffer1.putLong(1000L);
            buffer1.putLong(500L);
            buffer1.putInt(8);
            buffer1.putInt(512);

            fileFsSizeInfo.decode(buffer1.array(), 0, 24);
            long firstCapacity = fileFsSizeInfo.getCapacity();

            // Given - first decode
            ByteBuffer buffer1 = ByteBuffer.allocate(32);
            buffer1.order(ByteOrder.LITTLE_ENDIAN);
            buffer1.putLong(1000L);
            buffer1.putLong(500L);
            buffer1.putLong(500L);
            buffer1.putInt(8);
            buffer1.putInt(512);

            fileFsFullSizeInfo.decode(buffer1.array(), 0, 32);

            // First read
            byte[] buffer1 = new byte[60];
            SMBUtil.writeInt2(60, buffer1, 0);
            SMBUtil.writeInt2(1, buffer1, 2);
            SMBUtil.writeInt8(1000, buffer1, 40);
            SMBUtil.writeInt8(500, buffer1, 48);
            SMBUtil.writeInt4(0x01, buffer1, 56);

            response.readBytesWireFormat(buffer1, 0);

            assertEquals(1, response.getCloseFlags());

        byte[] buffer1 = new byte[256];
        byte[] buffer2 = new byte[256];

        // When
        int bytes1 = request.writeBytesWireFormat(buffer1, 0);
        int bytes2 = request.writeBytesWireFormat(buffer2, 10);

        // Then
        assertEquals(bytes1, bytes2);
        assertEquals(SMBUtil.readInt2(buffer1, 0), SMBUtil.readInt2(buffer2, 10));
    }

    @Test

    }

    @Test
    void testReadSetupWireFormat() {
        byte[] buffer = new byte[100];
        int result = response.readSetupWireFormat(buffer, 0, 100);
        assertEquals(0, result);
    }

    @Test
    void testReadParametersWireFormat() {
        byte[] buffer = new byte[100];
        int result = response.readParametersWireFormat(buffer, 0, 100);
        assertEquals(0, result);
    }

    @Test

            byte[] buffer1 = new byte[100];
            byte[] buffer2 = new byte[200];

            Arrays.fill(buffer1, (byte) 0x11);
            Arrays.fill(buffer2, (byte) 0x22);

            // First decode
            response.decode(buffer1, 0, 50);
            byte[] data1 = response.getData();

            // Second decode should overwrite
            response.decode(buffer2, 10, 60);

    void testMultipleReadsUpdateOffset() {
        byte[] buffer1 = new byte[] { 0x10, 0x00, 0x00, 0x00 }; // 16
        byte[] buffer2 = new byte[] { 0x20, 0x00, 0x00, 0x00 }; // 32

        response.readParameterWordsWireFormat(buffer1, 0);
        assertEquals(16L, response.getOffset(), "First read should set offset to 16");

        response.readParameterWordsWireFormat(buffer2, 0);

            byte[] buffer = new byte[512];

            int bytesWritten = req.writeBytesWireFormat(buffer, 0);

            assertEquals(48, SMBUtil.readInt2(buffer, 0)); // Structure size
            assertEquals(3, SMBUtil.readInt2(buffer, 2)); // Lock count
            assertArrayEquals(testFileId, Arrays.copyOfRange(buffer, 8, 24));

            // Each lock is 24 bytes

            NdrShort ndrShort = new NdrShort(50);
            NdrBuffer buffer1 = mock(NdrBuffer.class);
            NdrBuffer buffer2 = mock(NdrBuffer.class);
            when(buffer2.dec_ndr_short()).thenReturn(75);

            // When: Performing multiple operations
            ndrShort.encode(buffer1);
            ndrShort.decode(buffer2);

            // Then: Should handle both operations correctly