artifactSet.select(new ArtifactVariantSelector() {
            @Override
            ResolvedArtifactSet select(ResolvedVariantSet candidates, ImmutableAttributes requestAttributes, boolean allowNoMatchingVariants, ArtifactVariantSelector.ResolvedArtifactTransformer factory) {
                assert candidates.variants.size() == 2

    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)
    }

                      if (id instanceof ModuleComponentIdentifier) {
                          variants.each {
                              println "\$id -> \${it.displayName}"
                              if (it.displayName != 'default') {
                                  throw new AssertionError("Unexpected resolved variant \$it")
                              }
                          }
                      }

     */
    ResolvedVariant resolveAdhocVariant(VariantArtifactResolver variantResolver, List<IvyArtifactName> dependencyArtifacts);

    /**
     * Get all artifact variants, or "sub-variants" of this variant.
     */
    Set<? extends VariantResolveMetadata> getArtifactVariants();

cpp-unit-test-variant-task-graph.png...

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'"""
    }

        // We request sources for a variant that does not have sources.
        // We should not fail, since variant reselection allows no matching variants.
        "without-sources" | "[]"
        // We request sources for a variant that has sources and expect those sources to be reselected.
        "with-sources"    | "[\"producer-1.0-with-sources-sources.jar\"]"
    }

    }

    @Override
    public LocalConfigurationMetadata prepareToResolveArtifacts() {
        artifacts.finalizeIfNotAlready();
        for (LocalVariantMetadata variant : variants) {
            variant.prepareToResolveArtifacts();
        }
        return this;
    }

    @Override
    public ImmutableList<LocalComponentArtifactMetadata> getArtifacts() {
        return artifacts.get();

    def "cannot mutate outgoing variants after configuration is resolved"() {
        given:
        buildFile << """

        configurations {
            compile {
                attributes.attribute(usage, 'for compile')
                outgoing {
                    artifact file('lib1.jar')
                    variants {
                        classes {

     */
    @Nullable
    Identifier getIdentifier();

    DisplayName asDescribable();

    @Override
    ImmutableAttributes getAttributes();

    ImmutableList<? extends ComponentArtifactMetadata> getArtifacts();

    @Override
    ImmutableCapabilities getCapabilities();

    boolean isExternalVariant();

    /**
     * Is this variant eligible for caching?
     *