@Override
    Map<String, String> getVariantFileInformation(String linkage, String module, String variantModuleNameWithVersion) {
        return [name: staticLibraryName(module), url: withStaticLibrarySuffix(variantModuleNameWithVersion), extension: staticLibraryExtension]
    }

    @Override
    boolean publishesArtifactForLinkage(String linkage) {
        return linkage == 'Link'
    }

        return new SwiftLib()
    }

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

    @Override
    String getDevelopmentBinaryCompileTask() {
        return ":compileDebugSharedSwift"
    }

    @Override

        requirement.linkage == 'shared'
    }

    def "can use static variant as requirement"() {
        when:
        def requirement = library.static

        then:
        requirement.projectPath == 'project-path'
        requirement.libraryName == 'someLib'
        requirement.linkage == 'static'
    }

    def "can use api linkage as requirement"() {
        when:

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

        when:
        succeeds "mainExecutable"

        then:

        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"));

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

        when:
        succeeds("test")

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

        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'
        """

    }

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

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

    @Override

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

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

        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: