}


private
fun apiSpecFor(includes: List<String>, excludes: List<String>): PatternMatcher =
    when {
        includes.isEmpty() && excludes.isEmpty() -> PatternMatcher.MATCH_ALL
        includes.isEmpty() -> patternSpecFor(excludes).negate()
        excludes.isEmpty() -> patternSpecFor(includes)
        else -> patternSpecFor(includes).and(patternSpecFor(excludes).negate())
    }


private

    private final String path;
    private final File directory;
    private final List<String> excludes;
    private final List<String> includes;
    private final String output;

    public DefaultEclipseSourceDirectory(String path, File directory, List<String> excludes, List<String> includes, String output, List<DefaultClasspathAttribute> classpathAttributes, List<DefaultAccessRule> accessRules) {

    }

    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)

        then:
        rule.limits.size() == 2
        rule.limits[1] == limit
    }

    def "returned includes, excludes and limits are unmodifiable"() {
        when:
        rule.includes << ['*']

        then:
        thrown(UnsupportedOperationException)

        when:
        rule.excludes << ['*']

        then:
        thrown(UnsupportedOperationException)

        when:

        true  | true     | ["-g", "-O3"]
    }

    def "transforms system header and include args correctly"() {
        def spec = Stub(NativeCompileSpec)
        def includes = [ new File("/foo"), new File("/bar") ]
        def systemIncludes = [ new File("/baz") ]
        spec.includeRoots >> includes
        spec.systemIncludeRoots >> systemIncludes

        when:
        def args = transformer.transform(spec)

        1 * sourceParser.parseSource(file) >> sourceIncludes
        0 * sourceIncludes._

        and:
        def includes = includesParser.parseIncludes(file)

        then:
        includes.is(sourceIncludes)
    }

    Include include(String value, boolean isImport = false) {
        return TestIncludeParser.parse(value, isImport)
    }

import org.gradle.language.nativeplatform.internal.Include
import spock.lang.Specification


class DefaultSourceIncludesTest extends Specification {
    List<Include> includes = [ '"quoted1"', "<system1>", '"quoted2"', "macro1", "<system2>", "macro2" ].collect { TestIncludeParser.parse(it, false) }
    DefaultIncludeDirectives sourceIncludes = DefaultIncludeDirectives.of(ImmutableList.copyOf(includes), ImmutableList.of(), ImmutableList.of())

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.
"""

        // default is no-op
    }

    /**
     * Useful for quick dev cycles when you need to run test against a single file.
     *
     * @param includes ant-like includes, e.g. '**\SomeClass.java'
     */
    void includeOnly(String includes) {
        util.includes = includes
    }

        sourceSet.groovy.name == '<name>'
        sourceSet.groovy.displayName == '<display-name> Groovy source'
        def includes = sourceSet.groovy.filter.includes
        includes.size() == 2 && includes.containsAll(['**/*.groovy', '**/*.java'])
        sourceSet.groovy.filter.excludes.isEmpty()

        sourceSet.allGroovy.isEmpty()
        sourceSet.allGroovy.displayName =='<display-name> Groovy source'