def "flattens collections"() {
        when:
        dependency.add(toSet(otherTask))

        then:
        dependency.getDependencies(task) == toSet(otherTask)
    }

    def "flattens maps"() {
        when:
        dependency.add([key: otherTask])

        then:
        dependency.getDependencies(task) == toSet(otherTask)
    }

    def "flattens arrays"() {
        when:

        dir1.file("ignored1").createFile()
        def collection = containing(file1, file2, dir1, missing)

        expect:
        assertSetContainsForFileSet(collection, toSet("f1", "f2"))
        assertSetContainsForMatchingTask(collection, toSet("f1", "f2"))
    }

    void includesFilesAndContentsOfDirectoriesWhenConvertedToTreeAndAddedToAntBuilder() {
        TestFile testDir = this.testDir.getTestDirectory()

        }
    }

    def "does not use variant dimension names for single valued dimensions"() {
        when:
        NativeComponentRules.createBinariesImpl(component, platforms, [buildType].toSet(), [flavor].toSet(), nativePlatforms, nativeDependencyResolver, TestFiles.fileCollectionFactory())

        then:
        _ * component.targetPlatforms >> [platformRequirement]

        then:
        testCompileClasspath.extendsFrom == toSet(testCompileOnly, testImplementation)
        !testCompileClasspath.visible
        testCompileClasspath.transitive

        when:
        def defaultConfig = project.configurations.getByName(Dependency.DEFAULT_CONFIGURATION)

        then:
        defaultConfig.extendsFrom == toSet(runtimeElements)
    }

        }
        if (groupSetExcludes.size() > 1) {
            groupSetExcludes = ImmutableList.of(delegate.groupSet(groupSetExcludes.stream().flatMap(e -> e.getGroups().stream()).collect(toSet())));
        }
        if (moduleSetExcludes.size() > 1) {

            Set<JavaMethod> getters = gettersAndSetters.get(Boolean.TRUE).stream().map(Accessor::getMethod).collect(toSet());
            Set<JavaMethod> setters = gettersAndSetters.get(Boolean.FALSE).stream().map(Accessor::getMethod).collect(toSet());
            if (!getters.isEmpty() && !setters.isEmpty()) {
                return new Accessors(owningClass, propertyName, getters, setters);
            }

        def includedBuild2 = Mock(IncludedBuildInternal)

        rootProject.childProjects >> [].toSet()
        rootProject.identityPath >> Path.path(":some:identity:path")

        includedProject1.childProjects >> [].toSet()
        includedProject1.identityPath >> Path.path(":some:identity:path")
        includedProject2.childProjects >> [].toSet()
        includedProject2.identityPath >> Path.path(":some:identity:path")

        def composite = newCompositeFileTree([a, b])

        and:
        def visited = []
        composite.visit {
            visited << it.file
        }

        then:
        visited.toSet() == [a1, b1].toSet()
    }

    def "dependencies are union of dependencies of source trees"() {
        def task1 = Stub(Task)
        def task2 = Stub(Task)
        def task3 = Stub(Task)

import java.util.*;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;

import org.apache.maven.di.Key;

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

public abstract class BindingInitializer<T> {

    private final Set<Key<?>> dependencies;

    protected BindingInitializer(Set<Key<?>> dependencies) {
        this.dependencies = dependencies;
    }

import java.io.File;
import java.util.Collections;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.stream.Stream;

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

public class FileBasedInstallationFactory {

    public static Set<InstallationLocation> fromDirectory(File rootDirectory, String supplierName, BiFunction<File, String, InstallationLocation> locationFactory) {