// Test encode
        int encodeLength = transaction.encode(buffer, 0);
        assertTrue(encodeLength > 0);

        // Test decode - should not throw exception
        assertDoesNotThrow(() -> {
            transaction.decode(buffer, 0);
        });
    }

    @Test
    @DisplayName("Test configuration usage")
    void testConfigurationUsage() {
        // Verify configuration is used

        int encodedSize = context.encode(buffer, 0);

        // Create new context for decoding
        CompressionNegotiateContext decodedContext = new CompressionNegotiateContext();
        int decodedSize = decodedContext.decode(buffer, 0, encodedSize);

        assertEquals(encodedSize, decodedSize);
        assertArrayEquals(context.getCompressionAlgorithms(), decodedContext.getCompressionAlgorithms());

     * @return the resumeKey
     */
    public byte[] getResumeKey() {
        return this.resumeKey;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        if (len < 24) {

        if (idx >= 0) {
            name = name.substring(idx + 1);
        }
        try {
            return URLDecoder.decode(name, enc);
        } catch (final UnsupportedEncodingException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Failed to decode URL: " + name + " with encoding: " + enc, e);
            }
            return name;
        }
    }

    /**

        // Body starts at bufferIndex + 64
        // Structure size = 2
        SMBUtil.writeInt2(2, buffer, bufferIndex + 64);

        // Decode the response
        int result = response.decode(buffer, bufferIndex);

        assertEquals(66, result);
        assertEquals(0, response.getStatus()); // Should be STATUS_SUCCESS
    }

    @Test

        // Test decode method
        byte[] buffer = new byte[512];
        int bufferIndex = 0;
        int expectedDecodeLength = 128;
        when(response.decode(buffer, bufferIndex)).thenReturn(expectedDecodeLength);
        assertEquals(expectedDecodeLength, response.decode(buffer, bufferIndex));

        // Test encode method

    /**
     * Create a new durable handle V2 response
     */
    public DurableHandleV2Response() {
        // Will be populated during decode
    }

    @Override
    public byte[] getName() {
        return CONTEXT_NAME_BYTES;
    }

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        if (len != 8) {

                    final PermissionHelper permissionHelper = ComponentUtil.getPermissionHelper();
                    form.permissions = stream(entity.getPermissions()).get(stream -> stream.map(s -> permissionHelper.decode(s))
                            .filter(StringUtil::isNotBlank)
                            .distinct()
                            .collect(Collectors.joining("\n")));

     */
    public int getNextEntryOffset() {
        return this.nextEntryOffset;
    }

    /**
     * {@inheritDoc}
     *
     * @see jcifs.Decodable#decode(byte[], int, int)
     */
    @Override
    public int decode(final byte[] buffer, int bufferIndex, final int len) throws SMBProtocolDecodingException {
        final int start = bufferIndex;

        @DisplayName("fromUNIBytes should decode UTF-16LE bytes to string")
        void testFromUNIBytes() {
            // Given
            byte[] bytes = TEST_STRING.getBytes(StandardCharsets.UTF_16LE);

            // When
            String result = Strings.fromUNIBytes(bytes, 0, bytes.length);

            // Then
            assertEquals(TEST_STRING, result, "Should decode back to original string");
        }