def resourcefile1 = file("r1")
        def resourcefile2 = file("r2")
        def headerfile1 = file("h1")
        def headerfile2 = file("h2")
        def headerfile3 = file("h3")

        vsProject.addConfiguration(targetBinary([sourcefile1, sourcefile2], [resourcefile1, resourcefile2], [headerfile1, headerfile2, headerfile3]), Mock(VisualStudioProjectConfiguration))
        vsProject.addSourceFile(sourcefile3)

        then:

        assert headerFiles == sourceFiles(component.headerFiles, basePath)
    }

    void assertHasComponentSources(CppSourceElement component, String basePath) {
        assert sourceFiles == ['build.gradle'] + sourceFiles(component.sources.files, basePath)
        assert headerFiles == sourceFiles(component.headers.files, basePath)
    }

            }
        };
    }

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

        assert sourceFile(1) == "sourceTwo"

        assert headerFile(0) == "headerOne"
        assert headerFile(1) == "headerTwo"
    }

    private String sourceFile(int index) {
        def source = itemGroup('Sources').ClCompile[index]
        assert source.Filter[0].text() == 'Source Files'
        return source.'@Include'
    }

    private String headerFile(int index) {

    private final DefaultTaskDependency buildDependencies = new DefaultTaskDependency();
    private final ConfigurableFileCollection sourceFiles;
    private final ConfigurableFileCollection headerFiles;

    public DefaultVisualStudioProject(String name, String componentName, PathToFileResolver fileResolver, ObjectFactory objectFactory, ProviderFactory providerFactory) {
        this.name = name;

        def app = new CHelloWorldApp()
        app.executable.writeSources(file("src/main"))
        app.library.sourceFiles*.writeToDir(file("src/main"))
        app.library.headerFiles*.writeToDir(file("src/input"))
        degenerateInputSources()

        when:
        buildFile << """
    apply plugin: 'c'

model {
    components { comp ->

#endif
}

int main(int argc, char **argv) {
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}
                    """),
            ]
            List<SourceFile> headerFiles = [
            ]
        }
    }

    TestNativeComponent getSimpleTestExecutable() {
        return new TestNativeComponent() {
            List<SourceFile> sourceFiles = [

        run "visualStudio"

        then:
        executedAndNotSkipped ":visualStudio"

        and:
        final projectFile = projectFile("very/deeply/nested/mainExe.vcxproj")
        assert projectFile.headerFiles == app.headerFiles*.withPath("../../../src/main").sort()
        assert projectFile.sourceFiles == ['../../../build.gradle'] + app.sourceFiles*.withPath("../../../src/main").sort()
        projectFile.projectConfigurations.values().each {

            int main(int argc, char **argv) {
              if (42 == 42) {
                return 0;
              }
              return -1;
            }"""),
    ]

    List<SourceFile> headerFiles = []

    @Override
    SourceElement getHeaders() {
        return ofElements(sum.headers)
    }

    @Override
    SourceElement getSources() {
        return ofElements(sum.sources, sumTest.sources)

        generator.loadDefaults()
    }

    def "empty project file"() {
        expect:
        projectFile.projectConfigurations.isEmpty()
        projectFile.sourceFiles == []
        projectFile.headerFiles == []
    }

    def "set project uuid"() {
        when:
        generator.setProjectUuid("THE_PROJECT_UUID")

        then:
        projectFile.projectGuid == "THE_PROJECT_UUID"
    }