historyExecutions,
            history instanceof CrossBuildPerformanceTestHistory,
            historyExecutions.stream().map(PerformanceReportScenarioHistoryExecution::getTeamCityBuildId).noneMatch(performanceTestBuildIds::contains)
        );
    }

            return Optional.empty();
        }

        List<MavenProject> sortedProjects = result.getTopologicallySortedProjects();

        boolean hasNoSuccess =
                sortedProjects.stream().noneMatch(project -> result.getBuildSummary(project) instanceof BuildSuccess);

        if (hasNoSuccess) {
            return Optional.empty();
        }

        List<String> remainingProjects = sortedProjects.stream()

                exclusions.stream().map(ExclusionArtifactFilter::toPredicate).collect(Collectors.toList());
    }

    @Override
    public boolean include(Artifact artifact) {
        return predicates.stream().noneMatch(p -> p.test(artifact));
    }

    private static Predicate<Artifact> toPredicate(Exclusion exclusion) {
        PathMatcher groupId = FileSystems.getDefault().getPathMatcher("glob:" + exclusion.getGroupId());

        }

        for (File headerFile : vsProject.getHeaderFiles()) {
            projectFile.addHeaderFile(headerFile);
        }

        if (vsProject.getConfigurations().stream().noneMatch(it -> it.isBuildable())) {
            getLogger().warn("'" + vsProject.getComponentName() + "' component in project '" + getProject().getPath() + "' is not buildable.");
        }

                    .filter(entry -> verificationsBuilder.getTrustedKeys().stream()
                        .filter(trustedKey -> trustedKey.getKeyId().equals(e.getKey()))
                        .noneMatch(entry::checkAndMarkSatisfiedBy))
                    .collect(Collectors.toList());
                if (pgpKeys.size() > 1) {
                    // if there's only one entry, we won't "normalize" into globally trusted keys

            state.failedSignatures();
            if (((SignatureVerificationFailure) failure).getErrors().values().stream().map(SignatureVerificationFailure.SignatureError::getKind).noneMatch(kind -> kind == SignatureVerificationFailure.FailureKind.PASSED_NOT_TRUSTED)) {
                state.maybeCompromised();
            } else {
                state.hasUntrustedKeys();
            }

            options.setDocTitle(getTitle());
        }

        String maxMemory = getMaxMemory();
        if (maxMemory != null && options.getJFlags().stream().noneMatch(flag -> flag.startsWith("-Xmx"))) {
            options.jFlags("-Xmx" + maxMemory);
        }

        options.setSourceNames(sourceNames());

        JavadocSpec spec = createJavadocSpec(options);

            extensionsToPrint.addAll(extensions.stream()
                .flatMap(e -> e.getExtendedConfigurations().stream())
                .filter(e -> extensionsToPrint.stream().noneMatch(eToP -> eToP.name.equals(e.getName())))
                .map(e -> new FormattedExtension(e.getName(), true))
                .collect(Collectors.toList()));
            if (nonRecursiveCount != extensionsToPrint.size()) {

    }

    // A ∩ (A ∪ B) ∩ (A ∪ C) -> A
    // A ∪ (A ∩ B) ∪ (A ∩ C) -> A
    private Set<ExcludeSpec> simplifySet(Class<? extends CompositeExclude> clazz, Set<ExcludeSpec> specs) {
        if (specs.stream().noneMatch(clazz::isInstance)) {
            return specs;
        }
        ExcludeSpec[] asArray = specs.toArray(new ExcludeSpec[0]);
        boolean doDrop = false;
        for (int i = 0; i < asArray.length; i++) {

        }
    }

    private void warnAboutInsecureChecksums() {
        if (checksums.stream().noneMatch(SECURE_CHECKSUMS::contains)) {