public boolean hasRole(final String role) {
        return stream(user.getRoleNames()).get(stream -> stream.anyMatch(s -> s.equals(role)));
    }

    public boolean hasRoles(final String[] acceptedRoles) {
        return stream(user.getRoleNames())
                .get(stream -> stream.anyMatch(s1 -> stream(acceptedRoles).get(s3 -> s3.anyMatch(s2 -> s2.equals(s1)))));
    }

    public boolean hasGroup(final String group) {

                                .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());

        assertEquals(3, children.size());

        // Verify all children are present
        assertTrue(children.stream().anyMatch(f -> "file1.txt".equals(f.getName())));
        assertTrue(children.stream().anyMatch(f -> "file2.txt".equals(f.getName())));
        assertTrue(children.stream().anyMatch(f -> "dir1".equals(f.getName())));
    }

    @Test
    public void testMarkComplete() {

                    .anyMatch(p -> p.getFileName().toString().endsWith("yml"));
            }
            // check output for cases where tests are copied programmatically
            File yamlTestOutputDir = new File(additionalYamlTestsDir.get().getAsFile(), REST_TEST_PREFIX);
            if (yamlTestOutputDir.exists()) {
                return Files.walk(yamlTestOutputDir.toPath()).anyMatch(p -> p.getFileName().toString().endsWith("yml"));

                        + ")",
                    allTestClassFiles.getFiles()
                        .stream()
                        .filter(testFile -> classFilesPerTask.values().stream().anyMatch(fileSet -> fileSet.contains(testFile)) == false)
                        .map(classes::get)
                ),

            }

            project.getGradle().getTaskGraph().whenReady(graph -> {
                boolean needsVagrant = graph.getAllTasks().stream().anyMatch(t -> t instanceof VagrantShellTask);
                if (needsVagrant) {
                    checkVersion(project, "vagrant", VAGRANT_VERSION, 1, 8, 6);