.get("response.plugins");
                boolean exists = installed.stream()
                        .map(this::getArtifactFromMap)
                        .anyMatch(a -> a.getName().equals(target.getName()) && a.getVersion().equals(target.getVersion()));
                if (!exists) {
                    ThreadUtil.sleep(100);
                    continue;
                }

                            .stream()
                            .anyMatch(entry -> entry.getValue().toString().toLowerCase().contains(keywords[0].toLowerCase())),
                    doc.toString());
            assertFalse(
                    doc.entrySet()
                            .stream()
                            .anyMatch(entry -> entry.getValue().toString().toLowerCase().contains(keywords[2].toLowerCase())),

                        return false;
                    }
                    if (Arrays.stream(webProtocols).anyMatch(p -> s.startsWith(p))) {
                        return web;
                    }
                    if (Arrays.stream(fileProtocols).anyMatch(p -> s.startsWith(p))) {
                        return file;
                    }
                    return true;

        boolean hasThreadEntry = capturedOutput.stream().anyMatch(line -> line.startsWith("Thread:"));
        assertTrue("Should contain Thread: entries", hasThreadEntry);

        // Verify format - should contain stack trace entries
        boolean hasStackTrace = capturedOutput.stream().anyMatch(line -> line.startsWith("\tat "));
        assertTrue("Should contain stack trace entries", hasStackTrace);

        boolean p2IsRelease = p2Branches.stream().anyMatch(b -> b.startsWith("origin/release"));

        if (p1IsMaster && !p2IsMaster && p2IsRelease) {
            List<String> badFiles = filesFromMerge(commit).stream()
                .filter(gitFile -> MONITORED_PATHS.stream().anyMatch(forbiddenPath -> gitFile.startsWith(forbiddenPath)))
                .collect(Collectors.toList());

            if (StringUtil.isEmpty(key) || userBean
                    .map(user -> stream(user.getRoles()).get(stream -> stream.anyMatch(s -> (ROLE_VALUE_PREFIX + s).equals(key)))
                            || stream(user.getGroups()).get(stream -> stream.anyMatch(s -> (GROUP_VALUE_PREFIX + s).equals(key))))
                    .orElse(false)) {
                return p.getSecond();
            }

    @PostConstruct
    public void init() {
        final String filetypeField = ComponentUtil.getFessConfig().getIndexFieldFiletype();
        final Collection<String> values = queryMap.values();
        if (values.stream().anyMatch(s -> s.startsWith(filetypeField))) {
            final ResourceBundle resources = ResourceBundle.getBundle("fess_label", Locale.ENGLISH);
            final String[] fileTypes = ComponentUtil.getFileTypeHelper().getTypes();

        }
        return request;
    }

    private boolean consumerPomPresent(Collection<Artifact> artifacts) {
        return artifacts.stream()
                .anyMatch(a -> "pom".equals(a.getExtension()) && CONSUMER_POM_CLASSIFIER.equals(a.getClassifier()));
    }

    private Collection<Artifact> replacePom(Collection<Artifact> artifacts, boolean deployBuildPom) {

        assertTrue("Should have items from multiple fields", items.size() > 0);

        // Check that items come from different fields
        boolean hasContent = items.stream().anyMatch(i -> i.getFields()[0].equals("content"));
        boolean hasTitle = items.stream().anyMatch(i -> i.getFields()[0].equals("title"));
        assertTrue("Should have items from content field", hasContent);
        assertTrue("Should have items from title field", hasTitle);

            String isGetterName = "is" + Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1);
            return method.getReplacedAccessors().stream()
                .anyMatch(replacedAccessor -> replacedAccessor.getName().equals(isGetterName) && replacedAccessor.getDescriptor().equals("()Z"));
        }
        return false;
    }