if (variants.isEmpty()) {
            return maybeDeriveVariants();
        }
        ImmutableList.Builder<ModuleConfigurationMetadata> configurations = new ImmutableList.Builder<>();
        for (ComponentVariant variant : variants) {
            configurations.add(new RealisedVariantBackedConfigurationMetadata(getId(), variant, getAttributes(), getAttributesFactory()));
        }

        switch (failureSubType) {
            case NO_VARIANTS_EXIST:
                formatter.node("No variants exist.");
                break;
            case NO_VARIANTS_HAVE_ATTRIBUTES:
                formatter.node("None of the variants have attributes.");
                break;
            case NO_VARIANT_MATCHES_REQUESTED_ATTRIBUTES:
                // We're sorting the names of the configurations and later attributes

    suspend fun WriteContext.writeVariants(variants: Set<VariantResolveMetadata>) {
        writeCollection(variants) {
            writeVariant(it)
        }
    }

    private
    suspend fun WriteContext.writeVariant(variant: VariantResolveMetadata) {
        writeString(variant.name)
        write(variant.identifier)
        write(variant.attributes)
        writeCollection(variant.artifacts)
    }

The only attribute distinguishing these variants is 'org.gradle.docstype'. Add this attribute to the consumer's configuration to resolve the ambiguity:
  - Value: 'javadoc' selects variant: 'javadocElements'
  - Value: 'sources' selects variant: 'sourcesElements'"""
    }

public interface GraphSelectionCandidates {

    /**
     * Returns the set of variants to select from during attribute matching, or an empty list of this
     * component does not support attribute matching.
     */
    List<? extends VariantGraphResolveState> getVariantsForAttributeMatching();

    /**
     * Returns the variant to use when attribute-based variant selection is not enabled.
     */
    @Nullable

    ComponentGraphResolveMetadata getMetadata();

    /**
     * Returns the public view of all variants of this component that are available for variant selection, either during graph resolution or artifact resolution.
     */
    List<ResolvedVariantResult> getAllSelectableVariantResults();

    /**
     * Returns the candidates for variant selection during graph resolution.
     */

import org.gradle.test.fixtures.file.TestFile

class JvmTestSuitePluginIntegrationTest extends AbstractIntegrationSpec implements InspectsConfigurationReport {

    def "JVM Test Suites plugin adds outgoing variants for default test suite"() {
        settingsFile << "rootProject.name = 'Test'"

        buildFile << """
            plugins {
                id 'java'
            }
            """

        selectedVariants.put(id, variant);
    }

    @Override
    public void visitComponentVariants(List<ResolvedVariantResult> allVariants) {
        this.allVariants = ImmutableList.copyOf(allVariants);
    }

    @Override
    public void endVisitComponent() {

 * <ul>
 *     <li>Select a variant of the component instance. The variant selected for artifact resolution may be different to that used for graph resolution,
 *     for example when using an {@link org.gradle.api.artifacts.ArtifactView} to select different variants.</li>
 *     <li>Determine how to produce the artifacts of the variant, for example by running a chain of transformers.</li>

            formatter.node("Cannot choose between the available variants of ");
        } else {
            String node = "The consumer was configured to find " + describer.describeAttributeSet(failure.getRequestedAttributes().asMap());
            if (listAvailableVariants) {
                node = node + ". However we cannot choose between the following variants of ";
            } else {