String encoded = permissionHelper.encode(value);
            if (encoded != null) {
                String decoded = permissionHelper.decode(encoded);
                assertNotNull("Decoded value should not be null for: " + value, decoded);
                assertEquals("Decoded value should match original: " + value + " -> " + encoded + " -> " + decoded, value, decoded);
            }
        }
    }

        int offset = 5;
        original.encode(buffer, offset);

        // Decode from offset
        FileEndOfFileInformation decoded = new FileEndOfFileInformation();
        int decodedBytes = decoded.decode(buffer, offset, 8);
        assertEquals(8, decodedBytes);

        // Verify the values match
        assertEquals(original.toString(), decoded.toString());
    }

    /**

            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);
            byte[] data2 = response.getData();

            // Verify second decode overwrote first
            assertEquals(60, data2.length);

        }
    }

    @Nested
    @DisplayName("Decode Tests")
    class DecodeTests {

        @Test
        @DisplayName("Should decode valid copy chunk response")
        void testDecodeValidResponse() throws SMBProtocolDecodingException {
            byte[] buffer = createValidCopyChunkResponse(5, 65536, 327680);

            int bytesDecoded = response.decode(buffer, 0, buffer.length);

            EncryptionNegotiateContext decodedContext = new EncryptionNegotiateContext();
            int decoded = decodedContext.decode(buffer, 0, encoded);

            assertEquals(encoded, decoded);
            assertArrayEquals(originalCiphers, decodedContext.getCiphers());
        }

        @Test
        @DisplayName("Should encode and decode correctly with null ciphers")

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

            PreauthIntegrityNegotiateContext decoded = new PreauthIntegrityNegotiateContext();
            int decodedSize = decoded.decode(buffer, 0, encodedSize);

            assertEquals(encodedSize, decodedSize);
            assertArrayEquals(hashAlgos, decoded.getHashAlgos());
            assertArrayEquals(salt, decoded.getSalt());
        }

        @Test

        firstInstance.decode(originalBuffer, 0, originalBuffer.length);

        // Encode from first instance
        byte[] encodedBuffer = new byte[8];
        firstInstance.encode(encodedBuffer, 0);

        // Decode into second instance
        FileInternalInfo secondInstance = new FileInternalInfo();
        secondInstance.decode(encodedBuffer, 0, encodedBuffer.length);

        // Decode
        fileBothDirectoryInfo.decode(buffer, 0, buffer.length);

        // Verify - the decode method strips null termination, so filename should match
        assertEquals(expectedFilename, fileBothDirectoryInfo.getFilename());
    }

    @Test
    @DisplayName("Test decode with null-terminated non-Unicode filename")

        FileBasicInfo decoded = new FileBasicInfo();
        int decodedBytes = decoded.decode(buffer, 0, 36);

        // Verify encoding/decoding
        assertEquals(40, encodedBytes); // encode writes 40 bytes (includes padding)
        assertEquals(36, decodedBytes); // decode reads 36 bytes (no padding)
        assertEquals(original.getCreateTime(), decoded.getCreateTime());

        // When
        int encoded = messageBlock.encode(buffer, encodeIndex);
        int decoded = messageBlock.decode(buffer, decodeIndex);

        // Then
        assertEquals(encodeLength, encoded);
        assertEquals(decodeLength, decoded);
        verify(messageBlock).encode(buffer, encodeIndex);
        verify(messageBlock).decode(buffer, decodeIndex);
    }