.map(execution -> flakinessDataProvider.getScenarioRegressionResult(scenario.getPerformanceExperiment(), execution))
                        .collect(Collectors.toSet());
                    if (regressionResults.contains(STABLE_REGRESSION)) {
                        failureCollector.scenarioRegressed();

        if (configuration.isAutoDetectEnabled() || configuration.isDownloadEnabled()) {
            return cacheDirProvider.listJavaHomes().stream()
                .map(this::asInstallation)
                .collect(Collectors.toSet());
        } else {
            return Collections.emptySet();
        }
    }

    private InstallationLocation asInstallation(File javaHome) {

        return possibleInstallations.stream().map(this::resolveEnvironmentVariable)
            .filter(Optional::isPresent)
            .map(Optional::get)
            .collect(Collectors.toSet());
    }

    private Optional<InstallationLocation> resolveEnvironmentVariable(String environmentVariable) {
        final String value = environmentVariableValue(environmentVariable);
        if (value != null) {

import java.io.File;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

import static java.util.stream.Collectors.toList;
import static java.util.stream.Collectors.toSet;
import static java.util.stream.StreamSupport.stream;
import static org.gradle.util.internal.GroovyDependencyUtil.groovyModuleDependency;

/**

            def sourceRoots = sources.collect {
                it.url - 'file://$MODULE_DIR$/'
            } as Set

            def setDiff = CollectionUtils.diffSetsBy(sourceRoots, CollectionUtils.toSet(paths as List), InternalTransformers.noOpTransformer())
            assert setDiff.leftOnly.empty
            assert setDiff.rightOnly.empty
        }

        void assertContainsExcludes(String... paths) {

        final Collection<String> property = buildOptions.getInstallationsFromPaths();
        return property.stream()
            .filter(path -> !path.trim().isEmpty())
            .map(this::asInstallations).collect(Collectors.toSet());
    }

    private InstallationLocation asInstallations(String candidate) {
        return InstallationLocation.userDefined(fileResolver.resolve(candidate), getSourceName());
    }

                .filter(a -> a.getVersion().startsWith("3."))
                .map(a -> a.getGroupId() + ":" + a.getArtifactId() + ":" + a.getVersion())
                .collect(Collectors.toSet());

        if (!mavenArtifacts.isEmpty()) {
            pluginValidationManager.reportPluginValidationIssue(
                    PluginValidationManager.IssueLocality.EXTERNAL,
                    session,

			// in the term list of the union's type set).
			if f != nil {
				tset := f.typeSet()
				switch {
				case tset.NumMethods() != 0:
					check.errorf(tlist[i], InvalidUnion, "cannot use %s in union (%s contains methods)", t, t)
				case t.typ == universeComparable.Type():
					check.error(tlist[i], InvalidUnion, "cannot use comparable in union")
				case tset.comparable:

                .map(root -> FileBasedInstallationFactory.fromDirectory(root, getSourceName(), InstallationLocation::autoDetected))
                .flatMap(Set::stream)
                .collect(Collectors.toSet());
        }
        return Collections.emptySet();
    }

    }

    public Set<MavenArtifact> getAdditionalArtifacts() {
        return allArtifacts.stream()
                .filter(artifact -> artifact != pomArtifact && artifact != mainArtifact)
                .collect(Collectors.toSet());
    }

    public Set<MavenArtifact> getAllArtifacts() {
        return allArtifacts;
    }