credentialsProvider.setCredentials(authScope, authentication.getCredentials());
                if (authScope.getHost() != null && authScheme != null) {
                    final HttpHost targetHost = new HttpHost(authScope.getHost(), authScope.getPort());
                    authCache.put(targetHost, authScheme);
                }
            }
        }

        // This happens because the URL class parses "foo" as the host and "/bar" as the path
        assertEquals("/bar", actualPath, "Path should be /bar after URL parsing");
        assertEquals("foo", rel.getHost(), "Host should be 'foo' from the relative spec");
        assertNull(rel.getRef());
    }

    static Stream<Arguments> portSpecs() {
        return Stream.of(
                // spec, expectedPort

        StreamUtil.stream(groupsAndRoles.getFirst()).of(stream -> stream.forEach(groupList::add));
        StreamUtil.stream(groupsAndRoles.getSecond()).of(stream -> stream.forEach(roleList::add));
        if (logger.isDebugEnabled()) {
            logger.debug("[processParentGroup] Completed for id: {}, depth: {}, added groups: {}, added roles: {}", id, depth,
                    groupsAndRoles.getFirst().length, groupsAndRoles.getSecond().length);

            }
        })));
        getQueryFieldConfig().additionalDefaultList.stream().forEach(f -> {
            final QueryBuilder query = builder.apply(f.getFirst(), f.getSecond());
            defaultQuery.add(query);
        });
        return defaultQuery;
    }

    /**
     * Creates a default query builder based on the configured query type.

        int count = 0;
        String scrollId = response.getScrollId();
        try {
            while (scrollId != null) {
                final SearchHits searchHits = response.getHits();
                final SearchHit[] hits = searchHits.getHits();
                if (hits.length == 0) {
                    break;
                }

                final BulkRequestBuilder bulkRequest = client.prepareBulk();

                }
            }
        }

        if (repository.getProxy() != null && logger.isDebugEnabled()) {
            logger.debug("Using proxy " + repository.getProxy().getHost() + ":"
                    + repository.getProxy().getPort() + " for " + repository.getUrl());
        }

        if (repository.getAuthentication() != null && repository.getProxy() != null) {
            wagon.connect(

            final List<String> roles = new ArrayList<>();

            for (final Pair<String, String> searchFieldLog : searchLog.getSearchFieldLogList()) {
                final String name = searchFieldLog.getFirst();
                if (contentFieldNameSet.contains(name)) {
                    if (sb.length() > 0) {
                        sb.append(TEXT_SEP);
                    }

            proxySelector.add(
                    new org.eclipse.aether.repository.Proxy(
                            proxy.getProtocol(), proxy.getHost(), proxy.getPort(), authBuilder.build()),
                    proxy.getNonProxyHosts());
        }
        sessionBuilder.setProxySelector(proxySelector);

            params.put("User Agent", e.getUserAgent());
            e.getSearchFieldLogList().stream().forEach(p -> {
                params.put(p.getFirst(), p.getSecond());
            });
            e.getRequestHeaderList().stream().forEach(p -> {
                params.put(p.getFirst(), p.getSecond());
            });
            return params;
        }).get();
    }

    /**

                wildcard = dff.wildcard;
            }
            searchAttributes = dff.attributes;
        }
        final SmbResourceLocator locator = parent.getLocator();
        if (locator.getURL().getHost().isEmpty()) {
            // smb:// -> enumerate servers through browsing
            Address addr;
            try {
                addr = locator.getAddress();
            } catch (final CIFSException e) {