});

        if (logger.isDebugEnabled()) {
            logger.debug("role: {}", roleSet);
        }
        final String[] roles = roleSet.toArray(new String[roleSet.size()]);

        if (!subRoleSet.isEmpty()) {
            TimeoutManager.getInstance().addTimeoutTarget(() -> {
                processSubRoles(ldapUser, bindDn, subRoleSet, groupFilter, roleSet);
                if (logger.isDebugEnabled()) {

    @Override
    public Map<Attribute<?>, ?> asMap() {
        return asImmutable().asMap();
    }

    @Override
    public boolean isEmpty() {
        return keySet().isEmpty();
    }

    @Override
    public boolean contains(Attribute<?> key) {
        return keySet().contains(key);
    }

    @Override
    public AttributeContainer getAttributes() {

        AttributeMatcher attributeMatcher = consumerSchema.withProducer(targetComponent.getAttributesSchema());

        if (!consumerAttributes.isEmpty() && !conf.getAttributes().isEmpty()) {
            // Need to validate that the selected configuration still matches the consumer attributes
            if (!attributeMatcher.isMatching(conf.getAttributes(), consumerAttributes)) {

     * @see org.codelibs.fess.crawler.filter.UrlFilter#init(java.lang.String)
     */
    @Override
    public void init(final String sessionId) {
        this.sessionId = sessionId;
        if (!cachedIncludeSet.isEmpty()) {
            try {
                getUrlFilterService().addIncludeUrlFilter(sessionId, cachedIncludeSet.stream().collect(Collectors.toList()));
            } catch (final Exception e) {

    }

    public void assertLinesContainedIn(List<String> expectedLines, List<String> actualLines) throws LineSearchFailures.AbstractLineListComparisonFailure {
        assert !expectedLines.isEmpty() : "there must be expected text";
        assert !actualLines.isEmpty() : "there must be output text";

        if (actualLines.size() < expectedLines.size()) {
            LineSearchFailures.insufficientSize(expectedLines, actualLines);
        }

        List<Spec<FileTreeElement>> allIncludeSpecs = new ArrayList<>(1 + includeSpecs.size());

        Set<String> includes = patternSet.getIncludesView();
        if (!includes.isEmpty()) {
            allIncludeSpecs.add(createSpec(includes, true, patternSet.isCaseSensitive()));
        }

        allIncludeSpecs.addAll(includeSpecs);

        return Specs.union(allIncludeSpecs);
    }

    assertTrue(ArbitraryInstances.get(NavigableMap.class).isEmpty());
    assertTrue(ArbitraryInstances.get(LinkedList.class).isEmpty());
    assertTrue(ArbitraryInstances.get(Deque.class).isEmpty());
    assertTrue(ArbitraryInstances.get(Queue.class).isEmpty());
    assertTrue(ArbitraryInstances.get(PriorityQueue.class).isEmpty());
    assertTrue(ArbitraryInstances.get(BitSet.class).isEmpty());

        if (!config.getAttributes().isEmpty() ||
            (spec.isIncludeCapabilities() && !config.getCapabilities().isEmpty()) ||
            (spec.isIncludeArtifacts() && !config.getArtifacts().isEmpty()) ||
            (spec.isIncludeExtensions() && !config.getExtendedConfigurations().isEmpty()) ||
            (spec.isIncludeVariants() && !config.getSecondaryVariants().isEmpty())) {
            newLine();
        }

        return ((groupId != null && !groupId.isEmpty()) ? groupId : "[unknown-group-id]")
                + ':'
                + ((artifactId != null && !artifactId.isEmpty()) ? artifactId : "[unknown-artifact-id]")
                + ':'
                + ((version != null && !version.isEmpty()) ? version : "[unknown-version]");
    }

    /**

            this.implementationModulepath = implementationModulepath;
        }

        public boolean isEmpty() {
            return applicationClasspath.isEmpty() && applicationModulepath.isEmpty() &&
                implementationClasspath.isEmpty() && implementationModulepath.isEmpty();
        }
    }

    /**