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)

        then:
        assertHasArguments(args, "/I", includes)
        assertHasArguments(args, "/I", systemIncludes)

        and:

        def systemIncludes = [ new File("/baz") ]
        spec.includeRoots >> includes
        spec.systemIncludeRoots >> systemIncludes

        when:
        def args = transformer.transform(spec)

        then:
        assertHasArguments(args, "-I", includes)
        assertHasArguments(args, "-isystem", systemIncludes)

        and:

                final Callable<List<File>> systemIncludes = () -> binary.getPlatformToolProvider().getSystemLibraries(ToolType.CPP_COMPILER).getIncludeDirs();

                task.includes(binary.getCompileIncludePath());
                task.getSystemIncludes().from(systemIncludes);
                task.source(binary.getCppSource());
                if (binary.isDebuggable()) {

import org.gradle.language.nativeplatform.internal.IncludeDirectives
import org.gradle.language.nativeplatform.internal.IncludeType


class TestIncludeParser {
    static IncludeDirectives systemIncludes(Collection<String> names) {
        return DefaultIncludeDirectives.of(ImmutableList.copyOf(names.collect { new IncludeWithSimpleExpression(it, false, IncludeType.SYSTEM) }), ImmutableList.of(), ImmutableList.of())
    }

            plugins { id 'cpp-application' }
            task sysHeaders {
                doLast {
                    def out = file("${outputFile.toURI()}")
                    out.text = tasks.compileDebugCpp.systemIncludes.join('\\n')
                }
            }
        """

        when:
        //TODO this fails in CI (for unknown reasons) with project access checks based on configuration barrier

    def "can filter includes" () {
        expect:
        sourceIncludes.quotedIncludes.collect { it.value } == [ "quoted1", "quoted2" ]
        sourceIncludes.systemIncludes.collect { it.value } == [ "system1", "system2" ]
        sourceIncludes.macroIncludes.collect { it.value } == [ "macro1", "macro2" ]
    }

    def "order of includes is preserved" () {
        expect:

            </tr>
            <tr>
                <td>source</td>
            </tr>
            <tr>
                <td>includes</td>
            </tr>
            <tr>
                <td>systemIncludes</td>
            </tr>
        </table>
    </section>
    <section>
        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>

            List<DefaultSourceFile> sourceFiles = sourceFiles(namingSchemeFactory, platformToolProvider, compileTask.getObjectFileDir().get().getAsFile(), binary.getCppSource().getFiles());
            List<File> systemIncludes = ImmutableList.copyOf(compileTask.getSystemIncludes().getFiles());
            List<File> userIncludes = ImmutableList.copyOf(compileTask.getIncludes().getFiles());

    List<File> getIncludeRoots();

    void include(Iterable<File> includeRoots);

    void include(File... includeRoots);

    List<File> getSystemIncludeRoots();

    void systemInclude(Iterable<File> systemIncludeRoots);

    List<File> getSourceFiles();

    void setSourceFiles(Collection<File> sources);

    void source(Iterable<File> sources);

    List<File> getRemovedSourceFiles();

        addAll(this.includeRoots, includeRoots);
    }

    @Override
    public List<File> getSystemIncludeRoots() {
        return systemIncludeRoots;
    }

    @Override
    public void systemInclude(Iterable<File> systemIncludeRoots) {
        addAll(this.systemIncludeRoots, systemIncludeRoots);
    }

    @Override
    public List<File> getSourceFiles() {
        return sourceFiles;
    }