}
        };
    }

    @Override
    public List<SourceFile> getHeaderFiles() {
        ArrayList<SourceFile> headerFiles = new ArrayList<SourceFile>();
        headerFiles.addAll(getExecutable().getHeaderFiles());
        headerFiles.addAll(getLibrary().getHeaderFiles());
        return headerFiles;
    }

    @Override
    public List<SourceFile> getSourceFiles() {

            vsProject.getSourceFiles().from(cppApplication.getCppSource());
            vsProject.getHeaderFiles().from(cppApplication.getHeaderFiles());
            cppApplication.getBinaries().whenElementFinalized(CppExecutable.class, executable -> {

    }

    @Override
    public FileCollection getResourceFiles() {
        return projectLayout.files();
    }

    @Override
    public FileCollection getHeaderFiles() {
        return component.getHeaderFiles();
    }

    @Override
    public String getCleanTaskPath() {
        return taskPath("clean");
    }

    @Override
    public boolean isDebuggable() {

        return collect(getResourceFiles(), File::getAbsolutePath);
    }

    @Internal
    public ConfigurableFileCollection getHeaderFiles() {
        return headerFiles;
    }

    @Input
    public Set<String> getHeaderFilePaths() {
        return collect(getHeaderFiles().getFiles(), File::getAbsolutePath);
    }

    @Nested
    public List<VisualStudioProjectConfiguration> getConfigurations() {

        /**
         * Returns a file collection that contains the header files required by the source files.
         */
        FileCollection getHeaderFiles();
    }

            #import "foo.h"

            void sayFoo2()
            {
                std::cout << "foo2";
            }
        """)]
    }

    @Override
    List<SourceFile> getHeaderFiles() {
        [sourceFile("headers", "foo.h", """
            void sayFoo1();
            void sayFoo2();
           """)
        ]
    }

    public String getExtraConfiguration() {
        return """

abstract class TestNativeComponent extends SourceElement {
    List<SourceFile> getFiles() {
        return sourceFiles + headerFiles
    }

    abstract List<SourceFile> getSourceFiles()

    abstract List<SourceFile> getHeaderFiles()

    void writeSources(TestFile sourceDir) {
        for (SourceFile srcFile : files) {
            srcFile.writeToDir(sourceDir)
        }
    }

        for (File sourceFile : vsProject.getSourceFiles()) {
            filtersFile.addSource(sourceFile);
        }

        for (File headerFile : vsProject.getHeaderFiles()) {
            filtersFile.addHeader(headerFile);
        }

        for (Action<? super XmlProvider> xmlAction : vsProject.getFiltersFile().getXmlActions()) {
            getXmlTransformer().addAction(xmlAction);

            #include "foo.h"
            using namespace std;

            void foo2() {
                cout << "foo2";
            }
        """)]
    }

    @Override
    List<SourceFile> getHeaderFiles() {
        [sourceFile("headers", "foo.h", """
           void foo1();
           void foo2();
           """)
         ]
    }

            @Override
            List<SourceFile> getSourceFiles() {
                return getLibrarySources()
            }

            @Override
            List<SourceFile> getHeaderFiles() {
                return Arrays.asList(getLibraryHeader(), getCommonHeader())
            }
        }
    }