*
     * @return the library name
     */
    String getLibraryName();

    /**
     * Returns the variant of this binary.
     *
     * @return the library variant
     */
    String getVariant();

            @Override
            public File getFile() {
                artifactsAccessed(artifact.getVariant().getDisplayName());
                return artifact.getFile();
            }

            @Override
            public ResolvedVariantResult getVariant() {
                return artifact.getVariant();
            }

            @Override
            public ComponentArtifactIdentifier getId() {

        for (ResolvedGraphDependency d : dependencies) {
            DependencyResult dependencyResult;
            ResolvedVariantResult fromVariant = fromComponent.getVariant(d.getFromVariant());
            if (fromVariant == null) {

    public String getProjectPath() {
        return projectPath;
    }

    @Override
    public String getLibraryName() {
        return libraryName;
    }

    @Override
    public String getVariant() {
        return variant;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {

        @Override
        public List<ResolvedVariantResult> transform(Collection<ResolvedArtifactResult> artifacts) {
            return artifacts.stream().map(ResolvedArtifactResult::getVariant).collect(Collectors.toList());
        }
    }

    static class FileExtractor implements Transformer<List<RegularFile>, Collection<ResolvedArtifactResult>> {
        private final ProjectLayout projectLayout;

    }

    public static String getBuildScopedTerseName(LibraryBinaryIdentifier id) {
        return getProjectPrefix(id.getProjectPath()) + id.getLibraryName() + Project.PATH_SEPARATOR + id.getVariant();
    }

    private static String getProjectPrefix(String projectPath) {
        if (Project.PATH_SEPARATOR.equals(projectPath)) {
            return "";
        }

    def "associating the same result to a variant multiple times does not cause duplicate results"() {
        given:
        def module = newModule()
        def dependency = newDependency()
        def variant = module.getVariant(1)

        when:
        module.addDependency(dependency)

        module.associateDependencyToVariant(dependency, variant)
        module.associateDependencyToVariant(dependency, variant)

        then:

            }

            List<String> getAllToInstall() {
                return allToLink + [install]
            }
        }

        protected String getVariant() {
            String result = ""
            if (operatingSystemFamily != null) {
                result += operatingSystemFamily.toLowerCase().capitalize()
            }
            if (architecture != null) {

    @Override
    public List<? extends ModuleDependencyMetadata> getDependencies() {
        if (calculatedDependencies == null) {
            calculatedDependencies = variantMetadataRules.applyDependencyMetadataRules(getVariant(), super.getDependencies());
        }
        return calculatedDependencies;
    }

    /**
     * This class wraps the component variant so that attribute rules are executed once

            if (componentIdentifier.equals(currentProjectId)) {
                return;
            }
            LibraryElements libraryElements = artifact.getVariant().getAttributes().getAttribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE);
            if (libraryElements == null || !libraryElements.getName().equals(LibraryElements.JAR)) {
                return;
            }