private static final String KEY_DERIVATION_ALGORITHM = "PBKDF2WithHmacSHA256";
    private static final int KEY_SIZE = 256;
    private static final int GCM_TAG_SIZE = 128;
    private static final int GCM_IV_SIZE = 12;
    private static final int SALT_SIZE = 32;
    private static final int PBKDF2_ITERATIONS = 100_000;

    private final SecureRandom secureRandom = new SecureRandom();

        assertEquals(64, result.length()); // 32 bytes * 2 chars per byte
    }

    @ParameterizedTest
    @ValueSource(ints = { 1, 16, 32, 64, 128, 256 })
    @DisplayName("Should handle various data sizes")
    void testVariousDataSizes(int size) {
        // Given
        byte[] data = createTestData(size);

        // When
        String result = Hexdump.toHexString(data);

        // Then

        // Given
        int testType = 0x20; // Server service
        when(mockNetbiosName.getNameType()).thenReturn(testType);

        // When
        int nameType = mockNetbiosName.getNameType();

        // Then
        assertEquals(testType, nameType);
        verify(mockNetbiosName).getNameType();
    }

    @ParameterizedTest
    @ValueSource(ints = { 0x00, 0x03, 0x06, 0x1B, 0x1C, 0x1D, 0x1E, 0x20 })

        }
    }

    @ParameterizedTest
    @ValueSource(ints = { NtStatus.NT_STATUS_SUCCESS, NtStatus.NT_STATUS_PENDING, NtStatus.NT_STATUS_ACCESS_DENIED,
            NtStatus.NT_STATUS_INVALID_PARAMETER })
    @DisplayName("Should handle various status codes")
    void testVariousStatusCodes(int status) {
        response.setStatusForTest(status);
        assertEquals(status, response.getErrorCode());

            // When
            int size = copy.size();

            // Then
            assertEquals(HEADER_SIZE + CHUNK_SIZE, size);
        }

        @ParameterizedTest
        @DisplayName("Should return correct size with multiple chunks")
        @ValueSource(ints = { 1, 2, 3, 5, 10, 100 })
        void testSizeWithMultipleChunks(int chunkCount) {
            // Given

            for (int i = 0; i < 100; i++) {
                int bytesRead = response.readBytesWireFormat(buffer, 0);
                // Then
                assertEquals(4, bytesRead, "Failed at iteration " + i);
            }

            // When - perform multiple write operations
            for (int i = 0; i < 100; i++) {
                int bytesWritten = response.writeBytesWireFormat(buffer, 0);

    public static final int SMB_DIRECT_RESPONSE_REQUESTED = 0x00000001;
    
    // Default RDMA settings
    public static final int DEFAULT_RDMA_READ_WRITE_SIZE = 1048576;  // 1MB
    public static final int DEFAULT_RECEIVE_CREDIT_MAX = 255;
    public static final int DEFAULT_SEND_CREDIT_TARGET = 32;
    public static final int DEFAULT_MAX_RECEIVE_SIZE = 8192;
    public static final int DEFAULT_MAX_FRAGMENTED_SIZE = 131072;    // 128KB

        void testEncodeWithOffset() {
            String path = "\\\\test";
            int maxReferralLevel = 5;
            buffer = new DfsReferralRequestBuffer(path, maxReferralLevel);

            int offset = 10;
            byte[] dst = new byte[offset + buffer.size()];
            int bytesEncoded = buffer.encode(dst, offset);

            assertEquals(buffer.size(), bytesEncoded);

    void mapsKnownDosCodesToNtStatus(int dosCode, int expectedNtStatus) {
        // Act
        int actual = findNtStatusOrMinusOne(dosCode);

        // Assert
        assertEquals(expectedNtStatus, actual, "Mapping must match table entry");
    }

    @Test
    @DisplayName("Edge: zero DOS code maps to zero NTSTATUS")
    void zeroCodeMapsToZero() {
        // Act
        int actual = findNtStatusOrMinusOne(0x00000000);

    }

    /**
     * Test that a large file lock (bit 0x10 set) is encoded and decoded correctly.
     */
    @ParameterizedTest
    @ValueSource(ints = { 0x10, 0x11 })
    void largeFileFlagSet_and_decoded_according_to_type(int type) throws Exception {
        Configuration cfg = mock(Configuration.class);
        SmbComLockingAndX cmd = new SmbComLockingAndX(cfg);
        setField(cmd, "fid", 1);