}

        @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 {

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.

        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) {

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

        when:
        repositoryInteractions {

            outputContains("do something")
        }
        2.times {
            succeeds("other-build:doSomething")
            outputContains("do something")
        }
    }

    def "can run included build task included with --include-build"() {
        setup:
        settingsFile << ""
        file('other-build/settings.gradle') << "rootProject.name = 'other-build'"
        file('other-build/build.gradle') << """

            dir.file("settings$scriptLanguage.extension") << 'includeBuild("included-build")'

            dir.file("included-build", "build$scriptLanguage.extension") << dummyTaskIn(scriptLanguage)
            dir.file("included-build", "a", "build$scriptLanguage.extension") << dummyTaskIn(scriptLanguage)
            dir.file("included-build", "b").mkdir()