publicHeaders = objectFactory.fileCollection();
        publicHeadersWithConvention = createDirView(publicHeaders, "src/" + name + "/public");

        linkage = objectFactory.setProperty(Linkage.class);
        linkage.set(Collections.singleton(Linkage.SHARED));

        dependencies = objectFactory.newInstance(DefaultLibraryDependencies.class, getNames().withSuffix("implementation"), getNames().withSuffix("api"));

model {
    components {
        main(NativeExecutableSpec) {
            sources {
                cpp {
                    lib library: 'lib1', linkage: 'api'
                }
                otherCpp(CppSourceSet) {
                    lib library: 'lib2', linkage: 'api'
                }
            }
        }
    }
}
"""

        when:
        succeeds "mainExecutable"

        then:

                cpp.lib library: 'hello', linkage: 'api'
            }
        }
    }
}
"""

        when:
        succeeds "installMainExecutable"

        then:
        installation("build/install/main").exec().out == app.alternateLibraryOutput
    }

    @ToBeFixedForConfigurationCache
    def "can link to a prebuilt library with static and shared linkage"() {
        given:
        preBuildLibrary()

        when:
        def input = [project: 'other', library: 'libName', linkage: 'static']
        def dependency = parser.parseNotation(input)

        then:
        dependency.projectPath == "other"
        dependency.libraryName == "libName"
        dependency.linkage == "static"
    }

                library.linkage = [Linkage.${linkage}]
            }
        """
        lib.writeToProject(testDirectory)
        cppGreeter.asLib().writeToProject(file("cppGreeter"))

        when:
        succeeds("test")

        then:
        result.assertTasksExecuted(":cppGreeter:compileDebugCpp", ":cppGreeter:${createOrLink(linkage)}Debug",

    }

    @Override
    protected void makeSingleProject() {
        buildFile << """
            apply plugin: 'cpp-library'
            library.linkage = [Linkage.SHARED, Linkage.STATIC]
        """
    }

    @Override
    protected String getDevelopmentBinaryCompileTask() {
        return ":compileDebugSharedCpp"
    }

    @Override

        return new CppLib()
    }

    @ToBeFixedForConfigurationCache
    def "can create shared library binary when only shared linkage is specified"() {
        def library = new CppLib()
        buildFile << """
            apply plugin: 'cpp-library'

            library {
                linkage = [Linkage.SHARED]
            }
        """
        settingsFile << """
            rootProject.name = 'foo'
        """

        main(NativeExecutableSpec) {
            sources {
                cpp.lib library: 'hello', linkage: 'api'
                cpp.lib library: 'hello2'
            }
        }
        hello(NativeLibrarySpec)
        hello2(NativeLibrarySpec) {
            sources {
                cpp.lib library: 'hello', linkage: 'api'
            }
        }
    }
}
        """

        when:

_Depends on_: `__projectName__DllVisualStudioProject` (for shared linkage), `__projectName__DllVisualStudioFilters` (for shared linkage), `__projectName__LibVisualStudioProject` (for static linkage) and `__projectName__LibVisualStudioFilters` (for static linkage)
+
Generates all Visual Studio project files for the library component.

[[sec:visual_studio_configuration]]
== Configuration

        main(NativeExecutableSpec) {
            sources {
                cpp.lib library: "hello", linkage: "shared"
                cpp.lib library: "greetings", linkage: "shared"
            }
        }
        hello(NativeLibrarySpec) {
            sources {
                cpp.lib library: "greetings", linkage: "static"
            }
        }
        greetings(NativeLibrarySpec)
    }
}
"""