/**
     * Returns all the variants of this component available for selection. Does not include variants that cannot be consumed, which means this
     * may not include all the variants returned by {@link #getVariants()}.
     *
     * <p>
     * Note: for performance reasons,
     * {@link org.gradle.api.internal.artifacts.configurations.ResolutionStrategyInternal#setIncludeAllSelectableVariantResults(boolean)}

        this.variants = variants;
        this.selectedByVariantAwareResolution = selectedByVariantAwareResolution;
    }

    public List<? extends VariantGraphResolveState> getVariants() {
        return variants;
    }

    public boolean isSelectedByVariantAwareResolution() {
        return selectedByVariantAwareResolution;
    }

        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
     */

    }

    @Override
    public ImmutableAttributes getAttributes() {
        return variant.getAttributes().asImmutable();
    }

    @Override
    public Set<? extends VariantResolveMetadata> getVariants() {
        return ImmutableSet.of(variant);
    }

    @Override
    public boolean isCanBeConsumed() {
        return true;
    }

    @Override
    public boolean isTransitive() {

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

    @Nullable
    ImmutableAttributesFactory getAttributesFactory();

    VariantMetadataRules getVariantMetadataRules();

    VariantDerivationStrategy getVariantDerivationStrategy();