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

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;

    }

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

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

        def threadRange = 1..100

        when:
        def hashes = threadRange.collect {
            supplyAsync({ Hashing.hashString(currentThread().name) }, newFixedThreadPool(threadRange.size()))
        }*.join().toSet()

        then:
        hashes.size() == threadRange.size()
    }

    def 'null does not collide with other values'() {
        expect:
        def hasher = Hashing.newHasher()
        hasher.putNull()

        return Stream.concat(openJdkInstallations, jvms)
            .map(javaHome -> InstallationLocation.autoDetected(new File(javaHome), getSourceName()))
            .collect(Collectors.toSet());
    }

    private List<String> find(String sdkSubkey, String path, String value) {
        try {
            List<String> versions = getVersions(sdkSubkey);

        this.teamCityExecutions = teamCityExecutions
        this.crossBuild = crossBuild
        this.fromCache = fromCache

        Set<String> teamCityBuildIds = teamCityExecutions.collect { it.teamCityBuildId }.toSet()
        this.currentExecutions = historyExecutions.findAll {
            teamCityBuildIds.contains(it.teamCityBuildId)
        }
        this.historyExecutions = historyExecutions
    }

    String getName() {

                .filter(it -> JDK_PATTERN.matcher(it.getKey()).matches())
                .map(entry -> InstallationLocation.userDefined(new File(entry.getValue()), "env var " + entry.getKey()))
                .collect(Collectors.toSet());
        }
    }

    /**
     * On CI we pass -Porg.gradle.java.installations.paths=X,Y,Z to the build, then "forward" it
     * as system property to get deterministic results.
     */

            .filter(sourcePath -> sourcePath.endsWith(".java"))
            .flatMap(sourcePath -> sourceFileClassNameConverter.getClassNames(sourcePath).stream())
            .collect(Collectors.toSet());
        if (!classesWithJavaSource.isEmpty()) {
            // We need to collect just accessible dependents, since it seems
            // private references to classes are not problematic when Groovy compiler loads a class

        }
        return orig
            .stream()
            .map(ElementUtils::getTopLevelType)
            .map(ElementUtils::getElementName)
            .filter(Objects::nonNull)
            .collect(Collectors.toSet());
    }

    @Override
    public void recordGeneratedType(CharSequence name, Element[] originatingElements) {
        result.getGeneratedAggregatingTypes().add(name.toString());
    }

    @Override