DependencyResolverRequest.build(session, DependencyResolverRequest.RequestType.FLATTEN, project));
    }

    @Nonnull
    default DependencyResolverResult flatten(
            @Nonnull Session session, @Nonnull Project project, @Nonnull PathScope scope) {
        return flatten(DependencyResolverRequest.build(
                session, DependencyResolverRequest.RequestType.FLATTEN, project, scope));
    }

        1 -> providers.single()
        else -> composeProviders(providers)
    }

    public fun createFlattened(providers: List<P>): P =
        create(if (providers.size > 1) flatten(providers) else providers)

    public fun flatten(providers: List<P>): List<P> =
        providers.flatMap { provider ->
            // `KotlinCompositeProvider<P>` should always be a provider of type `P` itself, so the cast is legal. Still, suppressing the

        when:
        def eclipseModels = withConnection { con -> con.action(new LoadCompositeEclipseModels()).run() }

        then:
        eclipseModels.collect {
            collectProjects(it)
        }.flatten().collect {
            it.name
        }.containsAll([
            'root', 'root-a', 'explicitName',
            'includedBuild1', 'includedBuild1-a', 'includedBuild1-b', 'includedBuild1-c',

        } catch (DependencyCollectionException e) {
            throw new DependencyResolverException("Unable to collect dependencies", e);
        }
    }

    @Override
    public List<Node> flatten(Session s, Node node, PathScope scope) throws DependencyResolverException {
        InternalSession session = InternalSession.from(s);
        DependencyNode root = cast(AbstractNode.class, node, "node").getDependencyNode();

            collectOutputs(builder)
            builder.run()
        }

        then:
        eclipseModels.collect {
            collectProjects(it)
        }.flatten().collect {
            it.name
        }.containsAll([
            'root', 'root-root-a', 'explicitName',
            'includedBuild1', 'includedBuild1-a', 'includedBuild1-includedBuild1-b', 'includedBuild1-c',

        mainTestedVersions = testedVersions.map { VersionNumber.parse(it.gradleVersion().version) }
            .groupBy { it.major }
            .map { (_, v) -> listOf(v.minOrNull()!!.format(), v.maxOrNull()!!.format()) }.flatten()
    }

    private
    fun VersionNumber.format() =
        // reformat according to our versioning scheme, since toString() would typically convert 1.0 to 1.0.0

            return transformStepNodeIdentities
        }
        def targetColors = (identities.collect { it*.targetAttributes.color }.flatten() as Set<String>)
        return targetColors.collectEntries { color ->
            [(color): identities.collect {plannedTransformSteps ->

        return [true, false]
    }

    final def testCasesWithIndyModes() {
        // Combine each test case with enableIndy=true and/or enableIndy=false
        return [testCases(), indyModes()].combinations().collect { it.flatten() }
    }

    def "#title is intercepted in groovy build script #indyStatus"(VarInitializer varInitializer) {
        given:
        def cwd = testDirectory.file(expectedPwdSuffix)
        withPluginCode("""

     *
     * @return the id of the path scope
     */
    String pathScope() default "";

    /**
     * The request type, in case the default one is not correct.
     * Valid values are {@code collect}, {@code flatten}, or {@code resolve}.
     *
     * @return the request type
     */
    String requestType() default "";

        out.toString().contains("> Task $taskPath")
    }

    Collection<EclipseProject> collectProjects(EclipseProject parent) {
        return parent.children.collect { collectProjects(it) }.flatten() + [parent]
    }

    EclipseWorkspace eclipseWorkspace(List<EclipseWorkspaceProject> projects) {
        new DefaultEclipseWorkspace(temporaryFolder.file("workspace"), projects)
    }