strictlyEquals(new PatternSet(includes: ['i']), new PatternSet(includes: ['i']))
        strictlyEquals(new PatternSet(excludes: ['e']), new PatternSet(excludes: ['e']))
        strictlyEquals(new PatternSet(includes: ['i'], excludes: ['e']), new PatternSet(includes: ['i'], excludes: ['e']))

        new PatternSet() != new PatternSet(caseSensitive: false)
        new PatternSet() != new PatternSet(includes: ['i'])

    public PatternSet setIncludes(Iterable<String> includes) {
        this.includes = null;
        return include(includes);
    }

    @Override
    public PatternSet include(String... includes) {
        Collections.addAll(getIncludes(), includes);
        return this;
    }

    @Override
    public PatternSet include(Iterable includes) {
        for (Object include : includes) {

									</excludes>
								</resource>
								<resource>
									<directory>${project.basedir}</directory>
									<filtering>true</filtering>
									<includes>
										<include>bin/fess</include>
										<include>bin/fess.in.sh</include>
										<include>bin/generate-thumbnail</include>
										<include>bin/plugin.xml</include>
									</includes>
								</resource>

    }

    def "discards duplicate includes"() {
        when:
        sourceFile << """
    #include "test1"
    #include "test1"
    #include "test2"
    #include <test1>
    #include <test1>
    #include <test2>
    #include DEFINED
    #include DEFINED
    #include DEFINED()
    #include DEFINED()
    #include DEFINED(ABC)
    #include DEFINED(ABC)
    #include DEFINED(X)
    #include DEFINED(X, Y)

ignoring nonexistent directory "/include"
#include "..." search starts here:
#include <...> search starts here:
 /usr/local/include
 /usr/lib/llvm-3.6/bin/../lib/clang/3.6.0/include
 /usr/bin/../lib/gcc/x86_64-linux-gnu/4.8/include
 /usr/include/x86_64-linux-gnu
 /usr/include
End of search list.
"""

    public CopySpec setIncludes(Iterable<String> includes) {
        return getDelegateCopySpec().setIncludes(includes);
    }

    @Override
    public CopySpec setExcludes(Iterable<String> excludes) {
        return getDelegateCopySpec().setExcludes(excludes);
    }

    @Override
    public CopySpec include(String... includes) {
        return getDelegateCopySpec().include(includes);
    }

    @Override

    def "test excludes"() {
        expect:
        test.is(test.exclude(TEST_PATTERN_1, TEST_PATTERN_2))
        test.getExcludes() == toLinkedSet(TEST_PATTERN_1, TEST_PATTERN_2)

        when:
        test.exclude(TEST_PATTERN_3)

        then:
        test.getExcludes() == toLinkedSet(TEST_PATTERN_1, TEST_PATTERN_2, TEST_PATTERN_3)
    }

    def "--tests is combined with includes and excludes"() {
        given:

        )

        assertContainsGradleKotlinDslJars(scriptPluginClassPath)
    }

    def "sourcePath includes Gradle sources"() {

        expect:
        assertSourcePathIncludesGradleSourcesGiven("", "")
    }

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

        expect:
        assertSourcePathIncludesKotlinStdlibSourcesGiven(
            "",

     */
    @Internal("The paths for include directories are tracked via the includePaths property, the contents are tracked via discovered inputs")
    public ConfigurableFileCollection getIncludes() {
        return includes;
    }

    /**
     * Add directories where the compiler should search for header files.
     */
    public void includes(Object includeRoots) {
        includes.from(includeRoots);
    }

    /**

    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;