dependency.libraryName == "libName"
        dependency.linkage == null
    }

    def "parses map notation for library in other project"() {
        when:
        def input = [project: 'other', library: 'libName']
        def dependency = parser.parseNotation(input)


        then:
        dependency.projectPath == "other"
        dependency.libraryName == "libName"
        dependency.linkage == null

        then:
        requirement.projectPath == 'project-path'
        requirement.libraryName == 'someLib'
        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'
    }

import kotlin.contracts.contract

@KtModuleBuilderDsl
public class KtLibraryModuleBuilder(
    private val kotlinCoreProjectEnvironment: KotlinCoreProjectEnvironment
) : KtBinaryModuleBuilder() {
    public lateinit var libraryName: String
    public var librarySources: KtLibrarySourceModule? = null

    override fun build(): KtLibraryModule {
        val binaryRoots = getBinaryRoots()

            '}}}'
        }
    };

    public abstract String getBegin();

    public abstract String getEnd();

    public String declarationFor(String libraryName, String project = null) {
        """
        $begin
            library '$libraryName' ${project != null ? "project '$project'" : ''}
        $end
        """
    }

import org.gradle.platform.base.Binary;

public interface LibraryResolutionErrorMessageBuilder {
    String multipleCompatibleVariantsErrorMessage(String libraryName, Iterable<? extends Binary> binaries);

    String noCompatibleVariantErrorMessage(String libraryName, Iterable<? extends Binary> allBinaries);

import kotlin.contracts.contract

@KtModuleBuilderDsl
public class KtLibrarySourceModuleBuilder(
    private val kotlinCoreProjectEnvironment: KotlinCoreProjectEnvironment
) : KtModuleBuilder() {
    public lateinit var libraryName: String
    public lateinit var binaryLibrary: KtLibraryModule
    public lateinit var contentScope: GlobalSearchScope

    override fun build(): KtLibrarySourceModule {
        return KtLibrarySourceModuleImpl(

        protected NativeLibraryRequirement parseMap(
            @MapKey("library") String libraryName,
            @MapKey("project") @Nullable String projectPath,
            @MapKey("linkage") @Nullable String linkage
        ) {
            return new ProjectNativeLibraryRequirement(projectPath, libraryName, linkage);
        }
    }

        if (components == null) {
            return null;
        }
        String libraryName = libraryIdentifier.getLibraryName();
        NativeLibrarySpec library = components.withType(NativeLibrarySpec.class).get(libraryName);
        if (library == null) {
            return null;
        }

    override val directFriendDependencies: List<KtModule>,
    override val contentScope: GlobalSearchScope,
    override val platform: TargetPlatform,
    override val project: Project,
    override val libraryName: String,
    override val binaryLibrary: KtLibraryModule,
) : KtLibrarySourceModule, KtModuleWithPlatform {
    override val transitiveDependsOnDependencies: List<KtModule> by lazy {

    }

    private PrebuiltLibrary getPrebuiltLibrary(NamedDomainObjectSet<PrebuiltLibraries> repositories, String libraryName) {
        for (PrebuiltLibraries prebuiltLibraries : repositories) {
            PrebuiltLibrary prebuiltLibrary = prebuiltLibraries.resolveLibrary(libraryName);
            if (prebuiltLibrary != null) {
                return prebuiltLibrary;
            }
        }
        return null;