// Arrange
        byte[] buffer = new byte[100];
        SMBUtil.writeInt2(0, buffer, 0);
        SMBUtil.writeInt2(0, buffer, 2);
        SMBUtil.writeInt2(0, buffer, 4);

        // Act & Assert
        assertEquals(0, response.readSetupWireFormat(buffer, 0, 100));
        assertEquals(6, response.readParametersWireFormat(buffer, 0, 100));

            // Then
            assertEquals(4, bytesRead);
        }

        @Test
        @DisplayName("Should handle concurrent access safely")
        void testConcurrentAccess() throws InterruptedException {
            // Given
            byte[] buffer1 = new byte[10];
            byte[] buffer2 = new byte[10];
            SMBUtil.writeInt2(4, buffer1, 0);

        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

        byte[] buffer = new byte[context.size()];
        int bytesWritten = context.encode(buffer, 0);

        assertEquals(context.size(), bytesWritten);

        // Verify context header
        assertEquals(0, SMBUtil.readInt4(buffer, 0)); // Next
        assertEquals(16, SMBUtil.readInt2(buffer, 4)); // NameOffset
        assertEquals(4, SMBUtil.readInt2(buffer, 6)); // NameLength

        // Encode multiple times to verify consistency
        byte[] buffer1 = new byte[8];
        byte[] buffer2 = new byte[8];

        int bytes1 = info.encode(buffer1, 0);
        int bytes2 = info.encode(buffer2, 0);

        assertEquals(8, bytes1);
        assertEquals(8, bytes2);
        assertArrayEquals(buffer1, buffer2);
    }

    @Test
    @DisplayName("Test multiple decode operations")

        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

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

            // Encode to different buffers
            int result1 = request.encode(buffer1, 0);
            int result2 = request.encode(buffer2, 50);

            // Both should succeed independently
            assertTrue(result1 > 0);

            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[8];

        // Path consumed (2 bytes)
        SMBUtil.writeInt2(0, buffer, 0);

        // Number of referrals (2 bytes) - 0
        SMBUtil.writeInt2(0, buffer, 2);

        // Flags (2 bytes)
        SMBUtil.writeInt2(0, buffer, 4);

        // Padding (2 bytes)
        buffer[6] = 0;
        buffer[7] = 0;

        return buffer;
    }