when:
        def result = withConnection {
            action(new NoOpBuildAction()).run()
        }

        then:
        result == "result"
    }

    def "Can fetch build scoped models from included builds"() {
        given:
        singleProjectBuildInRootFolder("root") {
            settingsFile << """
                includeBuild 'includedBuild'
            """
        }

                }
            }
        }
    }

    @Issue("https://github.com/gradle/gradle/issues/5871")
    def "can inject substitutions into other builds when root build does not reference included builds via a dependency and included build has non-empty script classpath"() {
        mavenRepo.module("org.test", "plugin", "1.0").publish()

        given:
        buildA.buildFile << """
            task assembleB {

class ConfigurationCacheIncludedBuildInputsChangesIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "invalidates cache upon change to #inputName used by included build"() {

        assumeFalse(
            'property from gradle.properties is not available to included build',
            inputName == 'gradle.properties'
        )

        given:
        def configurationCache = newConfigurationCacheFixture()

    /**
     * Includes a plugin build at the specified path to the composite build, with the supplied configuration.
     * Included plugin builds can contribute settings and project plugins.
     * @param rootProject The path to the root project directory for the build.
     * @param configuration An action to configure the included build.
     *
     * @since 7.0
     */

        fails "t"

        then:
        failure.assertHasDescription("'buildSrc' cannot be used as a project name as it is a reserved name")
    }

    def "fails when trying to include buildSrc as project in an included build"() {
        settingsFile << """
            includeBuild 'i'
        """
        file("i/settings.gradle") << """
            include 'buildSrc'
        """
        buildFile << """
            task t

    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

                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

class SettingsSchemaAccessorsIntegrationTest : AbstractKotlinIntegrationTest() {

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