<includes>
										<include>logging.properties</include>
										<include>tomcat_config.properties</include>
									</includes>
								</source>
								<source>
									<location>${project.build.directory}/fess/WEB-INF/classes</location>
									<includes>
										<include>fess_config.properties</include>
										<include>fess_env_crawler.properties</include>

        return getDelegateCopySpec().include(includes);
    }

    @Override
    public CopySpec include(Spec<FileTreeElement> includeSpec) {
        return getDelegateCopySpec().include(includeSpec);
    }

    @Override
    public CopySpec include(Closure includeSpec) {
        return getDelegateCopySpec().include(includeSpec);
    }

    @Override

    public PatternFilterable include(Iterable<String> includes) {
        patterns.include(includes);
        return this;
    }

    @Override
    public PatternFilterable include(Spec<FileTreeElement> includeSpec) {
        patterns.include(includeSpec);
        return this;
    }

    @Override
    public PatternFilterable include(Closure includeSpec) {
        patterns.include(includeSpec);
        return this;

        settingsFile << """
            rootProject.name = 'broken'
            includeBuild("aaBb")
            include("aaaBbb")
            include("aaaaBbbb")
        """
        file("aaBb/settings.gradle") << """
            include("ccDD")
            include("cccDDD")
        """

        expect:
        fails(requested)
        failure.assertHasDescription(message)

        where:

        )

        assertContainsGradleKotlinDslJars(scriptPluginClassPath)
    }

    def "sourcePath includes Gradle sources"() {

        expect:
        assertSourcePathIncludesGradleSourcesGiven("", "")
    }

    def "sourcePath includes kotlin-stdlib sources resolved against project"() {

        expect:
        assertSourcePathIncludesKotlinStdlibSourcesGiven(
            "",

    }

    def "--tests is combined with includes and excludes"() {
        given:
        test.include(TEST_PATTERN_1)
        test.exclude(TEST_PATTERN_1)

        when:
        test.setTestNameIncludePatterns([TEST_PATTERN_2])

        then:
        test.includes == [TEST_PATTERN_1] as Set
        test.excludes == [TEST_PATTERN_1] as Set

        when:
        buildFile << """
            test {
                include 'FooTest*'
                exclude 'NotImportant*'
            }
        """
        failsWithTestTaskArguments("test", "--tests", 'FooTest.missingMethod')
        then: failure.assertHasCause("No tests found for given includes: [FooTest*](include rules) [NotImportant*](exclude rules) [FooTest.missingMethod](--tests filter)")
    }

        executed ":pluginBuild:jar", ":pluginDependencyA:taskFromPluginBuild", ":pluginDependencyA:compileJava", ":jar"
    }

    def "can co-develop plugin and consumer with both plugin and consumer as included builds using 'apply plugin' and library included build"() {
        given:
        applyPlugin(pluginDependencyA, false)

        buildA.buildFile << """
            dependencies {

        file('third/settings.gradle') << "include('t1')"

        when:
        run ":projects"

        then:
        outputContains """
Root project 'my-root-project'
No sub-projects

Included builds:

+--- Included build ':another'
\\--- Included build ':third'"""
    }

    def "included builds are only shown in the context of the root project"() {
        given:

#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>

#include "absl/container/flat_hash_map.h"
#include "absl/container/flat_hash_set.h"
#include "llvm/ADT/DenseMap.h"
#include "llvm/ADT/STLFunctionalExtras.h"
#include "llvm/ADT/SetVector.h"
#include "llvm/ADT/SmallPtrSet.h"
#include "llvm/ADT/SmallSet.h"
#include "llvm/ADT/SmallVector.h"