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) {

            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,

                .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;
    }

        when:
        delete.delete("someFile")
        delete.delete(new File("someOtherFile"))
        delete.getTargetFiles()

        then:
        delete.getDelete() == WrapUtil.toSet("someFile", new File("someOtherFile"))
        delete.getTargetFiles().getFiles() == getProject().files(delete.getDelete()).getFiles()
    }

    @Requires(UnitTestPreconditions.Symlinks)
    def "can follow symlinks"() {

    }

    private static actualThreadIds(String stdout) {
        String pattern = /.*\d+ - foo \d+ - (\d+)/
        return stdout.readLines().grep(~pattern).collect { (it =~ pattern)[0][1] }.toSet()
    }

import org.eclipse.sisu.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.helpers.MessageFormatter;

import static java.util.stream.Collectors.toSet;

/**
 */
@Named
@Singleton
public class DefaultMaven implements Maven {
    private final Logger logger = LoggerFactory.getLogger(getClass());

    private final Lookup lookup;

    val rootModuleComponents = rootDependencies.map { (it as ResolvedDependencyResult).selected.id }
    val candidateExternalComponents = (rootModuleComponents + externallyAccessible).filterIsInstance<ModuleComponentIdentifier>().toSet()
    return candidateExternalComponents - locallyAccessible