apply plugin: 'cpp-library'
                dependencies {
                    api project(':lib2')
                    implementation project(':lib3')
                }
            }
            project(':lib2') {
                apply plugin: 'cpp-library'
            }
            project(':lib3') {
                apply plugin: 'cpp-library'
            }
"""

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

            library {
                linkage = [Linkage.STATIC]
            }
        """
        settingsFile << """
            rootProject.name = 'foo'
        """
        library.writeToProject(testDirectory)

        when:

        "does not exist"                       | "library: 'unknown'"                    | "Could not locate library 'unknown' required by 'main' in project ':exe'."
        "project that does not exist"          | "project: ':unknown', library: 'hello'" | "Project with path ':unknown' not found."

    dependencyResolutionManagement {
        versionCatalogs {
            create("libs") {
                library("groovy-core", "org.codehaus.groovy:groovy:3.0.5")
                library("groovy-json", "org.codehaus.groovy:groovy-json:3.0.5")
                library("groovy-nio", "org.codehaus.groovy:groovy-nio:3.0.5")
                library("commons-lang3", "org.apache.commons", "commons-lang3").version {
                    strictly("[3.8, 4.0[")

        // Add the library and extension
        final DefaultCppLibrary library = componentFactory.newInstance(CppLibrary.class, DefaultCppLibrary.class, "main");
        project.getExtensions().add(CppLibrary.class, "library", library);
        project.getComponents().add(library);

        // Configure the component
        library.getBaseName().convention(project.getName());

                task.getTargetPlatform().set(library.getNativePlatform());
                task.getToolChain().set(library.getToolChain());
            });

            // Wire the task into the library model
            library.getLinkFile().set(createTask.flatMap(task -> task.getBinaryFile()));
            library.getLinkFileProducer().set(createTask);
            library.getCreateTask().set(createTask);

     * Converts this library to a native library requirement that uses the static library variant.
     */
    NativeLibraryRequirement getStatic();

    /**
     * Converts this library to a native library requirement that uses the api library linkage.
     */
    NativeLibraryRequirement getApi();

    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def "produces manifest for Swift library with shared and static linkage"() {
        given:
        buildFile << """
            plugins {
                id 'swiftpm-export'
                id 'swift-library'
            }
            library {
                linkage = [Linkage.SHARED, Linkage.STATIC]
            }
"""

    }

    def "fails when no linkage is specified"() {
        def library = new SwiftLib()
        buildFile << """
            apply plugin: 'swift-library'

            library {
                linkage = []
            }
        """
        settingsFile << """
            rootProject.name = 'foo'
        """
        library.writeToProject(testDirectory)

        when:
        fails('assemble')

        'java-library' | 'api'            | true              | false                     | "classes"
        'java-library' | 'api'            | false             | false                     | "jar"
        'java-library' | 'implementation' | true              | false                     | "classes"
        'java-library' | 'implementation' | false             | false                     | "jar"