}

        @Override
        public FilterResult apply(TestDescriptor descriptor) {
            if (classMatch(descriptor)) {
                return FilterResult.included("Class match");
            }
            return FilterResult.includedIf(shouldRun(descriptor), () -> "Method or class match", () -> "Method or class mismatch");
        }

        private boolean shouldRun(TestDescriptor descriptor) {

    def testCanVisitFiles() {
        File included1 = new File(testDir, 'subDir/included1')
        File included2 = new File(testDir, 'subDir2/included2')
        [included1, included2].each { File file ->
            file.parentFile.mkdirs()
            file.text = 'some text'
        }

        expect:
        assertVisits(fileTree, ['subDir/included1', 'subDir2/included2'], ['subDir', 'subDir2'])
    }

    def included
    def macros = []
    def macroFunctions = []
    def includePaths = [ systemIncludeDir ]

    def setup() {
        included = Mock(IncludeDirectives)
        included.getAllMacros() >> macros
        included.getMacros(_) >> { String name -> macros.findAll {it.name == name} }
        included.hasMacros() >> { !macros.empty }
        included.getAllMacroFunctions() >> macroFunctions

        containsSuccessfulProjectConfigurationOperation(":b", projectDir, ":b")
        containsSuccessfulProjectConfigurationOperation(":included", file("included"), ":")
        containsSuccessfulProjectConfigurationOperation(":included:c", file("included"), ":c")
    }

    void containsSuccessfulProjectConfigurationOperation(String displayName, TestFile rootDir, String projectPath) {

        }
    }

    def "emits deprecation warnings as build operation progress events for composite builds"() {
        file('included/settings.gradle') << "rootProject.name = 'included'"
        file('included/build.gradle') << """
            org.gradle.internal.deprecation.DeprecationLogger.deprecate('Included build script').willBeRemovedInGradle9().undocumented().nagUser();

            task t {
                doLast {

    }

    // buildSrc acts like an implicit pluginManagement { } included build
    def "library contributed by buildSrc is not visible to a build included by the root build"() {
        writeLibraryTo(file("buildSrc"))

        settingsFile << """
            includeBuild("included")
        """
        file("included/build.gradle") << """
            plugins { id("java-library") }
            dependencies {

        DirectoryScanner.removeDefaultExclude("**/.git/**")

        updateSettingsDefaults()

        then:
        included file('.gitignore')

        included dir('.git')
        included file('.git', 'abc')
        excluded file('foo', '.DS_Store')
    }

    boolean included(FileTreeElement file) {
        patternSet.asSpec.isSatisfiedBy(file)
    }

    boolean excluded(FileTreeElement file) {

Builds using these features function incorrectly when included in a composite build.

[[included_build_task_dependencies]]
== Depending on tasks in an included build

While included builds are isolated from one another and cannot declare direct dependencies, a composite build can declare task dependencies on its included builds.

        """

        then:
        succeeds()
        settingsPluginBuild.assertSettingsPluginApplied()
    }

    def "a build can depend on included library build that applies a project plugin that comes from an included settings plugin and depends on another included build"() {
        given:
        def pluginLibraryBuild = pluginAndLibraryBuild("plugin-lib")
        def projectPluginBuild = pluginBuild("project-plugin")

                }
        """
        file("included/settings.gradle") << """
            rootProject.name = 'included'
        """
        buildFile << """
            dependencies {
                conf 'com.acme:included:1.0'
            }
        """
        settingsFile << """
            includeBuild 'included'
        """

        when:
        repositoryInteractions {