return dependency.getSelected().getSelectionReason();
    }

    @Override
    public List<ResolvedVariantResult> getSelectedVariants() {
        return dependency.getSelected().getVariants();
    }

    @Override
    public List<ResolvedVariantResult> getAllVariants() {
        return ((ResolvedComponentResultInternal) dependency.getSelected()).getAvailableVariants();
    }

    @Override

        given:
        def comp1 = Stub(TestComponent) {
            getName() >> "foo"
        }
        def comp2 = Stub(TestComponent) {
            getVariants() >> [comp1]
            getName() >> "bar"
        }
        comp1.getVariants() >> [comp2]

        def publication = pub('mock', "pub-group", "pub-name", "pub-version", comp1)
        registry.register(project.identityPath, publication)

        variants = objectFactory.domainObjectSet(SoftwareComponent.class);
    }

    @Override
    public String getName() {
        return "main";
    }

    @Override
    public Set<SoftwareComponent> getVariants() {
        return variants;
    }

    public void addVariant(SoftwareComponent variant) {
        variants.add(variant);
    }

    @Override
    public Set<? extends UsageContext> getUsages() {

    @Override
    ImmutableAttributes getAttributes();

    /**
     * Returns the "sub variants" of this variant.
     *
     * <p>This concept should disappear.</p>
     */
    Set<? extends Subvariant> getVariants();

    List<? extends DependencyMetadata> getDependencies();

    List<? extends ExcludeMetadata> getExcludes();

    ImmutableCapabilities getCapabilities();

    boolean isTransitive();

    /**
     * Returns the variants of this configuration. Should include at least one value. Exactly one variant must be selected and the artifacts of that variant used.
     */
    Set<? extends VariantResolveMetadata> getVariants();

    /**
     * Returns the exclusions to apply to this configuration:
     * - Module exclusions apply to all outgoing dependencies from this configuration

        return ImmutableSet.of(new ConfigurationSoftwareComponentVariant(name, attributeContainer, artifacts, dependencies));
    }

    @Override
    public Set<? extends SoftwareComponent> getVariants() {
        return variants;
    }

    public void addArtifact(PublishArtifact artifact) {
        artifacts.add(artifact);
    }

    /**
     * Adds a child variant
     */

    /**
     * Returns the variants of this component
     */
    ImmutableList<? extends ComponentVariant> getVariants();

    @Nullable
    ImmutableAttributesFactory getAttributesFactory();

    VariantMetadataRules getVariantMetadataRules();

    VariantDerivationStrategy getVariantDerivationStrategy();

    }

    @Override
    public ModelMap<BinarySpec> getBinaries() {
        return ModelMaps.toView(binaries, BINARY_SPEC_MODEL_TYPE);
    }

    @Override
    public Iterable<Binary> getVariants() {
        return ModelMaps.toView(binaries, BINARY_MODEL_TYPE);
    }

        ImmutableList<ImmutableRealisedVariantImpl> variants = LazyToRealisedModuleComponentResolveMetadataHelper.realiseVariants(metadata, variantMetadataRules, metadata.getVariants());

        Map<String, ModuleConfigurationMetadata> configurations = realiseConfigurations(metadata, variantMetadataRules);

        if (variants.isEmpty()) {

                }
            }
        }
        graphSelector = Mock(GraphVariantSelector) {
            selectVariantsLenient(_, _, _, _, _) >> Mock(GraphVariantSelectionResult) {
                getVariants() >> [variant]
            }
        }
        consumerSchema = Mock(AttributesSchemaInternal)
    }

    def "returns empty set when component id does not match spec"() {
        when: