String getElement();

    /**
     * Sets list of elements that should be included in check.
     *
     * @param includes Inclusions
     */
    void setIncludes(List<String> includes);

    /**
     * List of elements that should be included in check. Names can use wildcards (* and ?).
     * If left empty, all elements will be included. Defaults to [*].
     */
    @Input
    List<String> getIncludes();

    /**

    }

    def "passes task options associated with a task originating from an included build"() {
        when:
        file('settings.gradle') << """
            rootProject.name = 'root-project'

            includeBuild 'included-build'
        """
        file('included-build/build.gradle') << """
            ${defineTaskWithProfileOption()}

In addition to the benefits of a multirepo architecture, using a Gradle composite build in this way allows a developer to easily choose which modules to develop as source dependencies and which to integrate via a binary repository.

== Running `multirepo-app` with dependencies from included builds

        when:
        fails("impl:modifyDependentConfigDuringTaskExecution")

        then:
        failure.assertHasCause("Cannot change dependencies of dependency configuration ':api:compile' after it has been included in dependency resolution.")
    }

class SettingsSchemaAccessorsIntegrationTest : AbstractKotlinIntegrationTest() {

    @Before
    fun withSettingsPluginFromIncludedBuild() {
        // given: a Settings plugin from an included build
        withDefaultSettingsIn("plugins")
        withBuildScriptIn(
            "plugins",
            """
                plugins { `kotlin-dsl` }
                $repositoriesBlock
            """

 * limitations under the License.
 */

package org.gradle.api.initialization;

/**
 * A plugin build that is to be included in the composite.
 *
 * @since 7.0
 */
public interface ConfigurableIncludedPluginBuild extends IncludedBuild {

    /**
     * Sets the name of the included plugin build.
     *
     * @param name the name of the build
     * @since 7.0
     */
    void setName(String name);

    @Override
    protected Class<AssembleSpec> getCompileSpecType() {
        AssembleSpec
    }

    @Override
    protected List<String> getCompilerSpecificArguments(File includeDir, File systemIncludeDir) {
        super.getCompilerSpecificArguments(includeDir, systemIncludeDir)
    }

    def "check that position sensitive arguments are in the right order"() {
        given:
        def genericArgs = [ '/c' ]

                def artifacts1 = filterView.artifacts
                def files6 = filterView.artifacts.artifactFiles
                doLast {
                    def all = ['included-1.3.jar', 'excluded-2.3.jar', 'libInclude.jar', 'libExclude.jar']
                    def filtered = ['included-1.3.jar', 'libInclude.jar']
                    assert files1.collect { it.name } == all
                    assert files2.files.collect { it.name } == all

    }

    def "can use lib produced by included build"() {
        given:
        def configurationCache = newConfigurationCacheFixture()
        withLibBuild()
        withAppBuild()

        when:
        inDirectory 'app'
        configurationCacheRun 'run'

        then:
        outputContains 'Before!'
        configurationCache.assertStateStored()

                compositeSubstitute()
            }
        }

        and:
        output.count('Configured buildC') == 1
    }

    def "configures included build only once when #action"() {
        given:
        dependency "org.test:buildB:1.0"
        dependency "org.test:buildC:1.0"

        includeBuild buildB
        includeBuild buildC, """