@Override
    public DefaultConfigurableFileTree include(String... includes) {
        patternSet.include(includes);
        return this;
    }

    @Override
    public DefaultConfigurableFileTree include(Iterable<String> includes) {
        patternSet.include(includes);
        return this;
    }

    @Override
    public DefaultConfigurableFileTree include(Closure includeSpec) {

        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

#include <iostream>
<%
includes.each { include ->
    out.println "#include \"$include\""
}
%>

int main(int argc, char**argv) {
    return 0;

}

type InterceptFilter struct {
	Values []string
	Except bool
}

func ParseInterceptFilter(include, exclude string) InterceptFilter {
	if include == "*" {
		excludes := Split(exclude)
		return InterceptAllExcept(excludes...)
	}
	includes := Split(include)
	return InterceptOnly(includes...)
}

func InterceptAllExcept(values ...string) InterceptFilter {
	return InterceptFilter{
		Values: values,

        true  | true     | ["/Zi", "/O2"]
    }

    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)

    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(
            "",

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

    void privateHeaders(Action<? super ConfigurableFileCollection> action);

    /**
     * Returns the private header include directories of this component, as defined in {@link #getPrivateHeaders()}.
     */
    FileCollection getPrivateHeaderDirs();

    /**
     * Returns all header files of this component. Includes public and private header files.
     */
    FileTree getHeaderFiles();

    /**