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

        then:
        methods.methodNames() == (["doSomething"] as Set)
        methods.allMethods().values().flatten()*.name == ["doSomething", "doSomething"]
        methods.allMethods().values().flatten()*.declaringClass == [Child, Base]
        methods.allMethods().values()*.declaredAnnotations.flatten()*.annotationType() == [Nullable, Incubating]
    }

    @Managed
    abstract class ManagedType  {

        outputs.fileProperties*.propertyFiles*.files.flatten() == [file("a"), file("b")]
    }

    def "can register named output files"() {
        when:
        outputs.files("fileA": "a", "fileB": "b")
        then:
        outputs.files.files == files('a', "b")
        outputs.fileProperties*.propertyName == ['$1.fileA', '$1.fileB']
        outputs.fileProperties*.propertyFiles*.files.flatten() == [file("a"), file("b")]

        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

        toWords("123Thing") == "123 thing"
        toWords(".") == ""
        toWords("_") == ""
    }

    def "flattens maps and arrays"() {
        expect:
        flatten([[1], [foo: 'bar']]) == [1, 'bar']

        Object[] array = [1]
        flatten([array, [foo: 'bar']]) == [1, 'bar']
    }

    def "flattening of maps controls flatting of arrays"() {

	matchers := make([][]string, 0, len(values))
	for _, value := range values {
		matchers = append(matchers, matcher(value))
	}
	return Flatten(matchers...)
}

func Flatten(lists ...[]string) []string {
	var result []string
	for _, list := range lists {
		result = append(result, list...)
	}
	return result

        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',

        def outputFile = testDir.file("output/lib")

        final expectedArgs = [
            "-emit-library",
            "-o", outputFile.absolutePath,
            testDir.file("one.o").absolutePath].flatten()

        when:
        NativePlatform platform = Mock(NativePlatform)
        platform.getOperatingSystem() >> new DefaultOperatingSystem(operatingSystem.name, operatingSystem)

		// Lookup remainder of path in each array element and
		// make result array.
		var result []interface{}
		for _, a := range arr {
			rval, flatten, err := jsonpathEval(p[1:], a)
			if err != nil {
				return nil, false, err
			}

			if flatten {
				// Flatten if array.
				if arr, ok := rval.([]interface{}); ok {
					result = append(result, arr...)
					continue
				}
			}

                assert files*.name == ['someDir']
            }
        }

        task run(dependsOn: configurations.compile) {
            doLast {
                assert files*.listFiles().flatten().text == ['some text']
            }
        }
        '''

        when:
        run 'check'

        then:
        executed ':check'

        when:
        run 'run'

        then: