when(mockClearScrollBuilder.addScrollId(any(String.class))).thenReturn(mockClearScrollBuilder);
        doAnswer(invocation -> {
            ActionListener<ClearScrollResponse> listener = invocation.getArgument(0);
            listener.onResponse(mock(ClearScrollResponse.class));
            return null;
        }).when(mockClearScrollBuilder).execute(any(ActionListener.class));

        doNothing().when(transport).connect();

        // Setup response for tree connect
        doAnswer(invocation -> {
            ServerMessageBlock request = invocation.getArgument(0);
            ServerMessageBlock response = invocation.getArgument(1);
            if (request instanceof SmbComTreeConnectAndX && response instanceof SmbComTreeConnectAndXResponse) {

        when(config.getPid()).thenReturn(1234);

        // Stub send to populate the provided response instance via reflection
        Mockito.doAnswer(inv -> {
            Object resp = inv.getArgument(1);
            // Set private fields: status on SmbComTransactionResponse and available on TransPeekNamedPipeResponse

        lenient().when(servletConfig.getInitParameterNames()).thenReturn(Collections.enumeration(initParams.keySet()));
        lenient().when(servletConfig.getInitParameter(anyString())).thenAnswer(invocation -> initParams.get(invocation.getArgument(0)));

        // Mock HTTP method for request - this is required for HttpServlet.service()
        lenient().when(request.getMethod()).thenReturn("GET");

        // Setup CIFSContext configuration mock

                entry("keep2", SmbConstants.TYPE_SHARE));

        // Filter accepts names starting with "keep"
        when(filter.accept(any())).thenAnswer(inv -> {
            SmbResource res = inv.getArgument(0);
            return res.getName().startsWith("keep");
        });

        ShareEnumIterator it = new ShareEnumIterator(parent, entries.iterator(), filter);

        // Returns only accepted resources

        Logger logger = mock(Logger.class);

        // Capture error messages for debugging
        doAnswer(invocation -> {
                    System.err.println("[ERROR] " + invocation.getArgument(0));
                    return null;
                })
                .when(logger)
                .error(anyString());

        when(request.parserRequest()).thenReturn(parserRequest);

        when(mockContext.getConfig()).thenReturn(mockConfig);

        // Mock random for predictable salt generation
        doAnswer(invocation -> {
            byte[] buffer = invocation.getArgument(0);
            System.arraycopy(testSalt, 0, buffer, 0, Math.min(buffer.length, testSalt.length));
            return null;
        }).when(mockRandom).nextBytes(any(byte[].class));
    }

    @Test

        ParameterizedClassDesc pcd = pd.getParameterizedClassDesc();
        assertThat(pcd.getRawClass(), is(sameClass(Map.class)));
        assertThat(pcd.getArguments().length, is(2));
        assertThat(pcd.getArguments()[0].getRawClass(), is(sameClass(String.class)));
        assertThat(pcd.getArguments()[1].getRawClass(), is(sameClass(Date.class)));

        pd = bd.getPropertyDesc("hege");
        assertThat(pd.isParameterized(), is(true));

        if (!Collection.class.isAssignableFrom(parameterTypes[index]) || !isParameterized(index)) {
            return null;
        }
        final ParameterizedClassDesc pcd = parameterizedClassDescs[index].getArguments()[0];
        if (pcd == null) {
            return null;
        }
        return pcd.getRawClass();
    }

    @Override
    public Class<?> getKeyClassOfMap(final int index) {

        assertThat(desc.getRawClass(), is(sameClass(Map.class)));

        final ParameterizedClassDesc[] args = desc.getArguments();
        assertThat(args.length, is(2));

        final ParameterizedClassDesc arg1 = args[0];
        assertThat(arg1.getRawClass(), is(sameClass(String.class)));
        assertThat(arg1.getArguments(), is(nullValue()));

        final ParameterizedClassDesc arg2 = args[1];